郭郭说Java03

郭郭说Java03,第1张

郭郭说Java03

Javaday02
  • 面向对象(预)
    • 方法(函数)
  • 面向对象(一)
    • 1.类与对象
    • 2.全局变量、成员方法、局部变量
    • 3.构造方法(构造器)
    • 4.对象的创建
    • 5.同一个类中不能同时存在两个方法名一样的方法,除非重载。
    • 6.有参构造
      • this关键字
    • 7.继承
    • 8.方法的重写和重载
    • 9.访问修饰符
    • 10.多态
      • instanceof
    • 11.封装(实体类必须封装)

面向对象(预)

你好! 这里是面向对象方面的知识,是最最最重点的部分,希望能带来帮助。

方法(函数)

方法:能够实现某个功能的代码块------------------(五要素)
格式: 1访问修饰符号 2返回值类型 3方法名(4参数列表<可有可无>){
5代码块
}
1.访问修饰符:public(公共的) protected(受保护的) default(默认的) private(私有的)
2.返回值类型:如果需要返回值,则用相应的返回值类型。(int…)有返回值一定要用return 返回相应的类型。
如果不需要方法返回结果,则需要用void返回值类型
3.方法名:命名规则和变量一样 (请看之前的博客)
4.参数列表:可有可无,如果需要第三方代码块则可以有。
无参:
public class HelloWord {
public static void main(String[] args) {
int n=add();
System.out.println(n);
}
public static int add(){
return 1+1;
}
}
有参:
public class HelloWord {
public static void main(String[] args) {
int n=add(3,4);
System.out.println(n);
}
public static int add(int a,int b){
return a+b;
}
}

面向对象(一) 1.类与对象

类:同一事物的总称。人类、种类…
电脑类
对象:客观存在的事物(具体存在)
我所使用的拯救者电脑
(万物皆对象)
eg:人类 ---->类
马爸爸----->对象(静态属性和动态行为)

属性:身高、体重、长相…
方法:动态行为就是方法。

类:
public class Human {
//属性:特点(静态)
String name;//姓名
int age;//年龄
String sex;//性别

//方法:行为(动态)
public void  say(){
    //说话的方法  代码块
    System.out.println("我要给博主10个亿~~");
}

}

2.全局变量、成员方法、局部变量

成员变量(全局变量):类的属性/特点(有默认初始值可以不用初始化)int–0;double—0.0; String–null
成员方法:类的行为
局部变量:在成员方法里面定义的属性(在方法创建时被创建在方法执行结束时被销毁)使用的时候必须赋值 *** 作或者初始化,否则会报错。

3.构造方法(构造器)

两类 (有参构造/无参构造)
定义:与类名同名的方法
构造方法没有返回值,并不是指void,而是直接省略返回值这个选项
作用:初始化
public class Human {
//属性:特点(静态)
String name;//姓名
int age;//年龄
String sex;//性别
//方法:行为(动态)
public Human(){
System.out.println(“我是构造方法”);
}
}

4.对象的创建

使用new关键字调用构造方法就可以创建一个对象
格式:类名 对象名=new 类名/构造方法();
public class Human {
//属性:特点(静态)
String name;//姓名
int age;//年龄
String sex;//性别
//方法:行为(动态)
public Human(){
System.out.println(“我构造方法”);
name=“郭郭”;
}
public void say(){
System.out.println(“给博主10个亿~~”);
}
public static void main(String[] args) {
//main 程序入口
//创建一个对象 格式:类名 对象名=new 类名/构造方法();

Human human=new Human();
//获取对象的属性: 对象名.属性
System.out.println(human.name);//null
//给对象属性赋值: 对象名.属性=值
human.name=“马爸爸”;
System.out.println(human.name);//GuoGuo
//调用普通方法 :对象名.方法()
human.say();
Human human1=new Human();
System.out.println(human= =human1);//false 每使用一次new都会创建一个新的对象
Human human2=human;
System.out.println(human==human2);//true ==作用在引用数据类型表示地址比较
System.out.println(human.equals(human1));//false

    Human human3=new Human();
    System.out.println(human3.name);//guoguo

}
}

5.同一个类中不能同时存在两个方法名一样的方法,除非重载。

重载:方法名相同,但参数列表不同(指参数列表类型、顺序不同与参数名无关。)方法的重载与方法访问修饰符以及返回值类型无关。
public int add(int a,int b){
return a+b;
}
public int add(int a,double b){
return (int)(a+b);
}

6.有参构造

如果一个类,没有构造器则会默认添加无参构造器。
Human human4=new Human(“郭郭”);
public Human(String s){
System.out.println(s);
}

this关键字

this:指代的是本类。
Human human4=new Human(“郭郭”);
public Human(String name){
System.out.println(name);//郭郭
System.out.println(this.name);//全局变量的name
this.name=name;
System.out.println(this.name);//郭郭
}

7.继承

继承:子类继承父类,会继承父类所有的非私有的属性和方法。
格式: public class 子类 extends 父类{
}---->表示子类继承父类
如何设计父类?
将子类共有特点和行为抽离定义成父类。
如何设计子类?
将子类特有的特点和行为定义在子类中,其他的特点和行为使用父类的

调用方法
如果子类中有和父类相同的方法,就会调用子类的方法父类的方法就会被覆盖-------->方法的覆盖(重写)

子类继承父类,则他们的构造方法执行顺序是?
无参构造器:
先执行父类的构造方法然后执行子类的方法。
this–>当前对象
super–>父类对象(this和super只能存在一个并且在第一行)
在子类构造器中,默认会在第一行添加super()调用父类的构造函数。
有参构造器:
子类中无论有参还是无参默认在第一行都是父类的无参构造器,然后调用子类有参构造器。

注意:1.Java只能单继承,一个Java类只能继承一个类
2.Java中可以多重继承,继承具有传递性。爷爷->爸爸->儿子

8.方法的重写和重载

重载overload:一个类,方法名相同,参数列表不同,顺序也不同,与参数名无关,与访问修饰符和返回值无关。
重写override:两个类以及以上,发生在子类和父类的关系上,当子类中含有和父类方法名相同参数列表也相同的方法时,就不会调用父类方法,直接调用子类方法。(两同两小一大)

9.访问修饰符

public(公共的) 同类 1 同包不同类 1 不同包子类 1 不同包非子类 1
protected(受保护的) 同类 1 同包不同类 1 不同包子类 1 不同包非子类 0
default(默认不写) 同类 1 同包不同类 1 不同包子类 0 不同包非子类 0
private(私有的) 同类 1 同包不同类 0 不同包子类 0 不同包非子类 0

10.多态

多态:同一种类型的多种形态。
必须继承同一个父类,必须与继承结合使用。
正常:Cat cat=new Cat();
System.out.println(cat.name);//cat类中的name(子类的name)
向上造型(多态)
//animal:这是一个动物
//cat1:被叫cat1
//new cat():cat1是一只猫
(小–>大 向上转型)
使用多态,属性调用关系看对象类型.
Animal cat1=new Cat();
System.out.println(cat1.name);//父类中的name
使用多态,方法的调用关系是子类覆盖父类。
cat.eat();
cat1.eat();
向下转型:(父类—>子类)

instanceof

A instanceof B:用于判断前面的A对象是否是B类的子类或者实现类的实例,返回Boolean类型。

11.封装(实体类必须封装)

封装:将所有的属性私有化(private修饰)只能在本类中访问,在其他类中访问的话需要通过类中提供特定的getxxx方法和setxxx方法。
public String getName(){
return name;//获取name的值
}
public void setName(String name){
this.name=name;//设置name的值
}
main方法内
person.setName(“郭郭”); //设置
String n=person.getName();
System.out.println(n);//得到

欢迎分享,转载请注明来源:内存溢出

原文地址: http://outofmemory.cn/zaji/5694260.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-12-17
下一篇 2022-12-17

发表评论

登录后才能评论

评论列表(0条)

保存