java-对象

0x01 面向对象

面向对象思想特点

* a:是一种更符合我们思想习惯的思想
* b:可以将复杂的事情简单化
* c:将我们从执行者变成了指挥者
    * 角色发生了转换

面向对象开发

* 就是不断的创建对象,使用对象,指挥对象做事情。

面向对象设计

* 其实就是在管理和维护对象之间的关系。

面向对象特征

* 封装(encapsulation)
* 继承(inheritance)
* 多态(polymorphism)

0x02 编程

我们学习编程是为了什么

* 为了把我们日常生活中实物用学习语言描述出来

我们如何描述现实世界事物

* 属性    就是该事物的描述信息(事物身上的名词)
* 行为    就是该事物能够做什么(事物身上的动词)

Java中最基本的单位是类,Java中用class描述事物也是如此

* 成员变量    就是事物的属性
* 成员方法    就是事物的行为

定义类其实就是定义类的成员(成员变量和成员方法)

* a:成员变量    和以前定义变量是一样的,只不过位置发生了改变。在类中,方法外。
* b:成员方法    和以前定义方法是一样的,只不过把static去掉,后面在详细讲解static的作用。

类和对象的概念

* a:类:是一组相关的属性和行为的集合
* b:对象:是该类事物的具体体现
* c:举例:
    * 类     学生
    * 对象    具体的某个学生就是一个对象

学生事物例子

* 学生类
* 案例演示
    * 属性:姓名,年龄,性别
    * 行为:学习,睡觉

0x03 java类

在类中的位置不同

* 成员变量:在类中方法外
* 局部变量:在方法定义中或者方法声明上

在内存中的位置不同

* 成员变量:在堆内存(成员变量属于对象,对象进堆内存)
* 局部变量:在栈内存(局部变量属于方法,方法进栈内存)

生命周期不同

* 成员变量:随着对象的创建而存在,随着对象的消失而消失
* 局部变量:随着方法的调用而存在,随着方法的调用完毕而消失

初始化值不同

* 成员变量:有默认初始化值
* 局部变量:没有默认初始化值,必须定义,赋值,然后才能使用。

注意事项:

* 局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则。
* 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
* 引用数据类型变量包括哪些:数组,类,接口,枚举; 参数传递的是:地址值 如:[I@23sd23d
* 如: 方法的参数是类名
1
2
public void print(Student s){}//print(new Student());
* 如果你看到了一个方法的形式参数是一个类类型(引用类型),这里其实需要的是该类的对象。

匿名对象应用场景

1
2
3
Car c = new Car(); 创建对象
c.run();
new Car().run();  匿名对象
* a:调用方法,仅仅只调用一次的时候。
    * 那么,这种匿名调用有什么好处吗?
        * 节省代码 
    * 注意:调用多次的时候,不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
* b:匿名对象可以作为实际参数传递

封装概述

* 是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。

封装好处

* 隐藏实现细节,提供公共的访问方式
* 提高了代码的复用性
* 提高安全性

封装原则

* 将不需要对外提供的内容都隐藏起来。
* 把属性隐藏,提供公共方法对其访问。

private关键字特点

* a:是一个权限修饰符
* b:可以修饰成员变量和成员方法
* c:被其修饰的成员只能在本类中被访问

案例演示
* 封装和private的应用:
* A:把成员变量用private修饰
* B:提供对应的getXxx()和setXxx()方法
* private仅仅是封装的一种体现形式,不能说封装就是私有

this关键字特点

* 代表当前对象的引用 

构造方法

A:构造方法概述和作用
* 给对象的数据(属性)进行初始化; 构造方法:不能被调用,但是在创建的时候就会执行。
B:构造方法格式特点
* a:方法名与类名相同(大小也要与类名一致)
* b:没有返回值类型,连void都没有
* c:没有具体的返回值return;

画图说明一个对象的创建过程做了哪些事情?
* Student s = new Student();
* 1,Student.class加载进内存
* 2,声明一个Student类型引用s
* 3,在堆内存创建对象,
* 4,给对象中属性默认初始化值
* 5,属性进行显示初始化
* 6,构造方法进栈,对对象中的属性赋值,构造方法弹栈
* 7,将对象的地址值赋值给s

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class Demo2_Person {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.show();

        System.out.println("---------------------");

        Person p2 = new Person("test",23);
        p2.show();

        System.out.println("---------------------");

        Person p3 = new Person("test",24);
        p3.show();
    }
}

class Person {
    private String name;            
    private int age;                

    public Person() {                
        System.out.println("构造");
    }

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("重载的有参构造"); //构造方法是将原对象类变成垃圾,在修改成员属性的时候不方便;getXxx(),setXxx() 灵活且方便,不用新建类;
    }
    
    public void show() {
        System.out.println(name + "..." + age);
    }
}

static关键字

A:static关键字的特点
* a:随着类的加载而加载
* b:优先于对象存在
* c:被类的所有对象共享
* 举例:咱们班级的学生应该共用同一个班级编号。
* 其实这个特点也是在告诉我们什么时候使用静态?
* 如果某个成员变量是被所有对象共享的,那么它就应该定义为静态的。
* 举例:
* 饮水机(用静态修饰)
* 水杯(不能用静态修饰)
* 共性用静态,特性用非静态
* d:可以通过类名调用
* 其实它本身也可以通过对象名调用。
* 推荐使用类名调用。
* 静态修饰的内容一般我们称其为:与类相关的,类成员

A:static的注意事项
* a:在静态方法中是没有this关键字的
* 如何理解呢?
* 静态是随着类的加载而加载,this是随着对象的创建而存在。
* 静态比对象先存在。
* b:静态方法只能访问静态的成员变量和静态的成员方法
* 静态方法:
* 成员变量:只能访问静态变量
* 成员方法:只能访问静态成员方法
* 非静态方法:
* 成员变量:可以是静态的,也可以是非静态的
* 成员方法:可是是静态的成员方法,也可以是非静态的成员方法。
* 简单记:
* 静态只能访问静态。

变量

静态变量也叫类变量,成员变量也叫对象变量
A:所属不同
* 静态变量属于类,所以也称为为类变量
* 成员变量属于对象,所以也称为实例变量(对象变量)
B:内存中位置不同
* 静态变量存储于方法区的静态区
* 成员变量存储于堆内存
C:内存出现时间不同
* 静态变量随着类的加载而加载,随着类的消失而消失
* 成员变量随着对象的创建而存在,随着对象的消失而消失
D:调用不同
* 静态变量可以通过类名调用,也可以通过对象调用
* 成员变量只能通过对 象名调用

代码块

  • A:代码块概述
    • 在Java中,使用{}括起来的代码被称为代码块。
  • B:代码块分类
    • 根据其位置和声明的不同,可以分为局部代码块,构造代码块,静态代码块,同步代码块(多线程讲解)。
  • C:常见代码块的应用
    • a:局部代码块
      • 在方法中出现;限定变量生命周期,及早释放,提高内存利用率
    • b:构造代码块 (初始化块)
      • 在类中方法外出现;多个构造方法方法中相同的代码存放到一起,每次调用构造都执行,并且在构造方法前执行
    • c:静态代码块
      • 在类中方法外出现,并加上static修饰;用于给类进行初始化,在加载的时候就执行,并且只执行一次。
      • 一般用于加载驱动
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        class Student {
            static {
                System.out.println("Student 静态代码块");
            }
            
            {
                System.out.println("Student 构造代码块");
            }
            
            public Student() {
                System.out.println("Student 构造方法");
            }
        }

        class Demo2_Student {
            static {
                System.out.println("Demo2_Student静态代码块");
            }
            
            public static void main(String[] args) {
                System.out.println("我是main方法");
                
                Student s1 = new Student();
                Student s2 = new Student();
            }
        }

静态代码块优先于主方法执行,构造代码块优先于构造方法执行
A:继承(extends)
* 让类与类之间产生关系,子父类关系
B:继承案例演示:
* 动物类,猫类,狗类
* 定义两个属性(颜色,腿的个数)两个功能(吃饭,睡觉)
A:继承的好处
* a:提高了代码的复用性
* b:提高了代码的维护性
* c:让类与类之间产生了关系,是多态的前提
B:继承的弊端
* 类的耦合性增强了。
* 开发的原则:高内聚,低耦合。
* 耦合:类与类的关系
* 内聚:就是自己完成某件事情的能力
A:Java中类的继承特点
* a:Java只支持单继承,不支持多继承。(一个儿子只能有一个爹)
* 有些语言是支持多继承,格式:extends 类1,类2,…
* b:Java支持多层继承(继承体系)
A:继承的注意事项
* a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
* b:子类不能继承父类的构造方法,但是可以通过super关键字去访问父类构造方法。
* c:不要为了部分功能而去继承
* 项目经理 姓名 工号 工资 奖金
* 程序员 姓名 工号 工资
A:this和super都代表什么
* this:代表当前对象的引用,谁来调用我,我就代表谁
* super:代表当前对象父类的引用
B:this和super的使用区别
* a:调用成员变量
* this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
* super.成员变量 调用父类的成员变量
* b:调用构造方法
* this(…) 调用本类的构造方法
* super(…) 调用父类的构造方法
* c:调用成员方法
* this.成员方法 调用本类的成员方法,也可以调用父类的方法
* super.成员方法 调用父类的成员方法
A:案例演示
* 父类没有无参构造方法,子类怎么办?
* super解决
* this解决
B:注意事项
* super(…)或者this(….)必须出现在构造方法的第一条语句上

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
        class Fu{
            public int num = 10;
            public Fu(){
                System.out.println("fu");
            }
        }
        class Zi extends Fu{
            public int num = 20;
            public Zi(){
                System.out.println("zi");
            }
            public void show(){
                int num = 30;
                System.out.println(num);
                System.out.println(this.num);
                System.out.println(super.num);
            }
        }
        class Test1_Extends {
            public static void main(String[] args) {
                Zi z = new Zi();
                z.show();
            }
        }

        看程序写结果2
        class Fu {
            static {
                System.out.println("静态代码块Fu");
            }
    
            {
                System.out.println("构造代码块Fu");
            }
    
            public Fu() {
                System.out.println("构造方法Fu");
            }
        }
    
        class Zi extends Fu {
            static {
                System.out.println("静态代码块Zi");
            }
    
            {
                System.out.println("构造代码块Zi");
            }
    
            public Zi() {
                System.out.println("构造方法Zi");
            }
        }
    
        Zi z = new Zi(); 请执行结果。

方法重写

A:什么是方法重写
* 重写:子父类出现了一模一样的方法(注意:返回值类型可以是子父类)
B:方法重写的应用:
* 当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法。这样,即沿袭了父类的功能,又定义了子类特有的内容。
C:案例演示
* a:定义一个手机类。

A:方法重写注意事项
* a:父类中私有方法不能被重写
* 因为父类私有方法子类根本就无法继承
* b:子类重写父类方法时,访问权限不能更低
* 最好就一致
* c:父类静态方法,子类也必须通过静态方法进行重写
* 其实这个算不上方法重写,但是现象确实如此,至于为什么算不上方法重写,多态中我会讲解(静态只能覆盖静态)
* 子类重写父类方法的时候,最好声明一模一样。

* Override和Overload的区别?Overload能改变返回值类型吗?
* overload可以改变返回值类型,只看参数列表
* 方法重写:子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的
* 方法重载:本类中出现的方法名一样,参数列表不同的方法。与返回值类型无关。
* 子类对象调用方法的时候:
    * 先找子类本身,再找父类。

A:final概述
B:final修饰特点
* 修饰类,类不能被继承
* 修饰变量,变量就变成了常量,只能被赋值一次
* 修饰方法,方法不能被重写
* 基本类型,是值不能被改变
* 引用类型,是地址值不能被改变,对象中的属性可以改变
C:案例演示
* final修饰特点
A:final修饰变量的初始化时机
* 显示初始化
* 在对象构造完毕前即可

0x04 面向对象(main方法的格式详细解释)

格式

* public static void main(String[] args) {}

针对格式的解释

* public 被jvm调用,访问权限足够大。
* static 被jvm调用,不用创建对象,直接类名访问
* void被jvm调用,不需要给jvm返回值
* main 一个通用的名称,虽然不是关键字,但是被jvm识别
* String[] args 以前用于接收键盘录入的

对工具类加入文档注释

通过javadoc命令生成说明书
* @author(提取作者内容)
* @version(提取版本内容)
* javadoc -d 指定的文件目录 -author -version ArrayTool.java
* @param 参数名称//形式参数的变量名称@return 函数运行完返回的数据

0x05 Math类

A:Math类概述
* 类包含用于执行基本数学运算的方法
B:Math类特点
* 由于Math类在java.lang包下,所以不需要导包。
* 因为它的成员全部是静态的,所以私有了构造方法
C:获取随机数的方法
* public static double random():返回带正号的 double 值,该值大于等于 0.0 且小于 1.0。
D:我要获取一个1-100之间的随机数,肿么办?
* int number = (int)(Math.random()*100)+1;
当一个类里面的方法都是static方法,可以private私有这个类的构造方法,防止其它类来使用创建类调用,直接使用类型.方法的调用即可。

0x06 多态

多态概述
* 事物存在的多种形态

多态前提
* 要有继承关系
要有方法重写
要有父类引用指向子类对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
    class Test{
        public static void main(String[] args){
            Cat c = new Cat();
            c.eat();
            System.out.println(c.num);

            Animal a = new Cat();  //父类引用指向子类对象, 就是向上转型
            a.eat();                    
            //成员方法:编译看左边(父类), 运行看右边(子类)[也叫动态绑定]
            //静态方法:编译看左边, 运行看左边
            System.out.println(a.num);  //成员变量:编译看左边(父类), 运行看左边(父类)
            Cat sm = (Cat)a;    //一定先有向上转型,才有这个向下转型
            sm.test();
        }
    }

    class Animal {
        int num = 10; //成员变量
        public void eat(){
            System.out.println("动物吃饭");
        }
    }

    class Cat extends Animal {
        int num = 20;
        public void eat() {
            System.out.println("猫吃鱼");
        }
        public void test() {
            System.out.println("test");
        }
    }
    结果:
        "猫吃鱼"
        20
        "猫吃鱼"
        10
        "test"

0x07 抽象和接口

抽象类不能直接实列,可以通过子类进行示例(父类引用,指向子类对象)
抽象类的子类,要不是抽象类,要不就直接重写抽象类中的所有方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
abstract class test{
    public abstract void eat() {
        System.out.println("helloworld !!!");
    }
}
* abstract 不能和其它关键字并用: static , final , private

* 接口的定义
    interface 接口名 {}
* 类实现接口用implements 表示
    class 类名 implements 接口名 {}
* 接口不能实列化: 可以通过多态来实例化
* 接口成员特点
    * 成员变量:只能是常量,并且是静态的并公共的
        默认修饰符:public static final
    * 构造方法:接口没有构造方法
    * 成员方法:只能是抽象方法
        默认修饰符:pulic abstract

* 类与类,类与接口,接口与接口的关系
    * 类与类:
        继承关系,只能但继承,可以多层继承
    * 类与接口:
        实现关系,可以单实现,也可以多实现
        并且还可以再继承一个类的同时实现多个接口
    * 接口与接口
        继承关系,可以单继承,也可以多继承

0x08 面向对象(package关键字的概述及作用)

A:为什么要有包
* 将字节码(.class)进行分类存放
* 包其实就是文件夹
B:包的概述
* 举例:
学生:增加,删除,修改,查询
老师:增加,删除,修改,查询

方案1:按照功能分
    com.heima.add
        AddStudent
        AddTeacher
    com.heima.delete
        DeleteStudent
        DeleteTeacher
    com.heima.update
        UpdateStudent
        UpdateTeacher
    com.heima.find
        FindStudent
        FindTeacher
方案2:按照模块分
    com.heima.teacher
        AddTeacher
        DeleteTeacher
        UpdateTeacher
        FindTeacher
    com.heima.student
        AddStudent
        DeleteStudent
        UpdateStudent
        FindStudent

A:定义包的格式
* package 包名;
* 多级包用.分开即可
B:定义包的注意事项
* A:package语句必须是程序的第一条可执行的代码
* B:package语句在一个java文件中只能有一个
* C:如果没有package,默认表示无包名
A:如何编译运行带包的类
* a:javac编译的时候带上-d即可
* javac -d . HelloWorld.java
* b:通过java命令执行。
* java 包名.HellWord
* 不同包下类之间的访问: 先编译,在调用的时候需要加包名

A:为什么要有import
* 其实就是让有包的类对调用者可见,不用写全类名了
B:导包格式
* import 包名;
* 注意:
* 这种方式导入是到类的名称。
* 虽然可以最后写*,但是不建议。
C:package,import,class有没有顺序关系

修饰符

* 权限修饰符:private,默认的,protected,public
* 状态修饰符:static,final
* 抽象修饰符:abstract

* 权限修饰符:默认修饰符,public
* 状态修饰符:final
* 抽象修饰符:abstract
* 用的最多的就是:public

成员变量

* 权限修饰符:private,默认的,protected,public
* 状态修饰符:static,final
* 用的最多的就是:private

构造方法

* 权限修饰符:private,默认的,protected,public
* 用的最多的就是:public

成员方法

* 权限修饰符:private,默认的,protected,public
* 状态修饰符:static,final
* 抽象修饰符:abstract
* 用的最多的就是:public

除此以外的组合规则

* 成员变量:public static final
* 成员方法:
    * public static 
    * public abstract
    * public final
1
2
3
4
5
            本类     同一个包下(子类和无关类)    不同包下(子类)    不同包下(无关类)
private     Y        
默认            Y        Y
protected    Y        Y                            Y
public        Y        Y                            Y                Y

内部类访问特点

* a:内部类可以直接访问外部类的成员,包括私有。
* b:外部类要访问内部类的成员,必须创建对象。
* 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    class Outer {
        public int num = 10;
        class Inner {
            public int num = 20;
            public void show() {
                int num = 30;
                System.out.println(?);
                System.out.println(??);
                System.out.println(???);
            }
        }
    }
    class InnerClassTest {
        public static void main(String[] args) {
            Outer.Inner oi = new Outer().new Inner();
            oi.show();
        }    
    }
* 局部内部类访问局部变量必须用final修饰
* 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用。
但是jdk1.8取消了这个事情。

A:匿名内部类
* 就是内部类的简化写法。
B:前提:存在一个类或者接口
* 这里的类可以是具体类也可以是抽象类。
C:格式:
new 类名或者接口名(){
重写方法;
}
D:本质是什么呢?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    * 是一个继承了该类或者实现了该接口的子类匿名对象。
    //这里写抽象类,接口都行

    abstract class Person {
        public abstract void show();
    }

    class PersonDemo {
        public void method(Person p) {
            p.show();
        }
    }

    class PersonTest {
        public static void main(String[] args) {
            //如何调用PersonDemo中的method方法呢?
            PersonDemo pd = new PersonDemo ();
            
        }
    }
坚持原创技术分享,您的支持将鼓励我继续创作!