Java学习笔记------面向对象

Java面向对象

类和对象

类：一些具有相同特性的功能事务的模板，是对一类数据或逻辑的抽象整合

对象：通过类实例化出来的具体内容，可操作的对象

在Java中，调用任意内容都是通过对象去调用的（static修饰的除外）

类

在类中只有四种内容：

属性（全局变量，成员变量，特征） – 就是一些静态值

行为（函数，方法，成员方法）– 就是一些动态的函数

静态块

实例化块

是对现实事务抽象的形容，其实类就是为了封装数据和封装逻辑

对象

类的实例化，调用属性和行为的具体变量

对象数组

Student [] stus = new Student[10];
stus[0] = new Student();
stus[0].no = 1;
stus[0].name = "张三";
stus[0].sex = "男";
stus[0].score = 90;

对象数组初始化，和基本数据类型没有区别

但是每⼀个对象数组的格⼦中，都是⼀个对象，但是这些对象初始化都为空(null)
要给对象数组中每个格⼦赋值，需要先new对象 stus[0] = new Student();

java.lang.NullPointerException
⼀般这种异常出现在如果对象为空，但是去调⽤了对象的属性或者⽅法的时候，就会报出异常

成员变量与局部变量

接写在类下⾯的变量 叫做 成员变量（全局变量，属性）
放在⽅法中声明的变量，叫做局部变量

只有同样是成员变量或者局部变量的情况，才会出现同名报错的情况
如果成员变量和局部变量出现同名，就会触发就近原则，哪个近使⽤哪个，⼀般肯定是直接使⽤局部变量
所以，为了防⽌这种情况，我们可以使⽤this关键字

this

this 一般出现在类中，代替是当前对象

this也可以调用构造器

this（）表示本地不带参构造器

如果手动在构造器中使用this（），非第一排会报错

public Person(int id, String name, int age){
 this(id,name);
 this.age = age;
}
public Person(int id, String name){
 this(id);
 this.name = name;
}
public Person(int id){
 this();
 this.id = id;
}
public Person(){}

包

其实就是在写代码时候的⽂件夹
包要注意的问题
1、包名全部⼩写
2、包名不要以java,class开头 java.test.xxx
3、包的命名习惯是域名倒着写

基本数据类型与应用数据类型的区别

基本数据类型 值传递

引用数据类型 引用传递

基本数据类型之间的赋值是值传递，相当于就是把值复制粘贴了⼀份

int a = 10;
int b = a;
b = 20;
System.out.println("a==" + a);
System.out.println("b==" + b);

对象之间的赋值是引⽤传递：

Student s1 = new Student();
s1.id = 1;
s1.name = "zhangsan";
s1.score = 90;
Student s2 = s1;
System.out.println(s2.id + " " + s2.name + " " + s2.score);
System.out.println("=======修改了S2对象的值======");
s2.id = 2;
s2.name = "lisi";
s2.score = 99;
System.out.println(s2.id + " " + s2.name + " " + s2.score);
System.out.println("-------S1对象的值--------");
System.out.println(s1.id + " " + s1.name + " " + s1.score);

如果对象之间赋值，不想引起引⽤传递的问题，可以先new不同的对象，然后对象的值再⼀⼀赋值

Student s1 = new Student();
s1.id = 1;
s1.name = "zhangsan";
s1.score = 90;
Student s2 = new Student();
s2.name = s1.name;
s2.id = s1.id;
s2.score = s1.score;

如果已经有两个不同的对象了，另外⼀个对象再赋值，还是会指向同⼀个地址，之前的引⽤就会被抛弃掉

类的行为

类和类之间的关系

泛化关系 – 继承和实现

依赖关系

一个类的方法中，需要依赖另外一个类

一般实现方式都是：

1.在类中的方法中，有另一个类对象的实例

2.在类中的方法参数中，需要另一个类的对象

public class Boy {
 String name;
 public void play(Dog d){
 d.dogName = "旺财";
 d.happy();
 System.out.println(name + "玩耍的很⾼兴~~~");
 }
 /*public void play(){
 Dog d = new Dog();
 d.dogName = "旺财";
 d.happy();
 System.out.println(name + "玩耍的很⾼兴~~~");
 }*/
}

组合（聚合）关系

一个类在另一个类中作为属性出现

public class Student {
 int id;
 String studentName;
 double score;
 MyClass clazz;
}
public class MyClass {
 int id;
 String className;
 Student [] stus = new Student[50];
}

构造函数（构造方法，构造器）

当new对象的时候会自动调用方法

注意：默认类其实就有一个默认构造方法，只是没有手动调而已

public 类名（）{}

可以手动给构造器自己想要的参数

public 类名（int xxx，string xxxx）{}

当写了带参构造器会覆盖默认不带参构造器

重载

在同⼀个类中，⽅法名⼀样，但是参数的个数,参数的类型或者不同参数类型的顺序不⼀样，就可以实现重载

public Person(int id, String name, int age){
this.id = id;
this.name = name;
this.age = age;
}
public Person(int id, String name){
this.id = id;
this.name = name;
}
public Person(int id){
this.id = id;
}
public Person(){
}

public void test(int age,String ss){}
public void test(String s,int a){}

如果写了不带参的构造器，会覆盖默认的构造器
最佳实践就是: 如果要写不带参的构造器，那么最好能把默认的构造器写⼀遍

final

final修饰符，可以修饰变量，方法以及类

final修饰变量 表示变量不能再被修改，所以一般意义上我们称呼final修饰的变量为常量，而且注意一个问题，常量必须要有初始值

注意：在Java中，我们一般习惯上声明一个常量 static final ，并且常量名全部大写，static和final都是修饰符，所以先后顺序没有规定static final，final static

final 可以修饰方法，当修饰方法的时候这个方法不能被重写

final可以修饰类，当修饰类的时候，这个类不能再被继承

static

static 可以修饰变量和方法，当被static修饰的时候，这个变量或方法就会被叫做静态变量或静态方法，他们是有别于成员变量和成员方法的

static修饰的变量或方法是属于整个类的，而不是某个对象的

static修饰的变量有唯一值，而且只会生成一次

静态的方法中，只能引用本类的静态的方法或变量，如果要引用其他方法只能用对象进行调用

静态的变量和方法在初始化的时候优先级比成员变量和成员方法高

访问修饰符

1.public 公共的，公开的 完全公开的

2.private 私有的 只能在类的内部使用

3.protected 受保护的

4.默认的

protected和默认的，在同一个包下面和public访问权限一致

在不同的包中，对象不能直接访问protected和默认的修饰的变量和方法

在不同的包中，子类中可以访问protected修饰的变量和方法

Java访问控制法的含义和使用情况

	类内部	本包	子类	外部包
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

JavaBean

程序员在经过长期的代码编程过程中，总结出来的经验，如果我们要封装一个类，这个类的作用仅仅就是用来存储数据的，那么可以把这个类封装为Javabean

JavaBean格式：

所有属性全部都是private修饰的

而每个属性都配置getter和setter方法

静态块与实例化块

静态块

static{
    
}

实例化块

{
    
}

变量的初始值

类的属性（成员变量），当对象初始化的时候，会自动初始化成员变量的值

整形 0

浮点型 0.0

布尔型 false

字符型 ascll的值

引用型 null

java局部变量不会自动赋初始值

继承

1、extends关键字

2、⼦类继承⽗类

3、⽗类中可以被访问的属性和⽅法都能被⼦类继承

4、⼦类可以继承⽗类的⽗类…

5、java的继承有单根性 – ⼦类只能有⼀个⽗类，⽗类可以有多个⼦类

当new ⼦类()对象的时候，会先调⽤⽗类的默认⽆参构造器，如果⽗类没有默认⽆参构造器，就会报
错。

修改错误的最佳办法就是，⽗类加上⽆参构造器

super

super和this用法一样，只是super代替的是父类

super(),表示⽗类的构造器，调⽤⽗类的构造器必须写在⼦类构造器的第⼀⾏

重写

条件：

1、继承

2、⼦类重写⽗类的⽅法

3、⽅法名，参数个数和类型都必须⼀样

4、⼦类重写⽅法的访问修饰符不⼩于⽗类的⽅法

5、返回值⼀样

6、声明的异常要⼀样

instanceof

判断某个对象是不是某个类型

`

Son s = new Son();
Father f = new Father();

System.out.println(s instanceof Son);
System.out.println(f instanceof Father);
System.out.println(-------------------------);
System.out.println(s instanceof Father);
System.out.println(-------------------------);
System.out.println(f instanceof Son);

结果
ture
ture
------------------------
ture
------------------------
false

可以进行类型转换的原因：1.有继承关系 2.父类的引用指向子类对象

报ClassCastExcption的原因：没有指向子类引用

多态（运行时加载）

条件：

1.继承

2.父类引用指向子类对象

3.子类重写父类方法

object

所有类的父类

toString()
getClass()
equals()
wait()
notify()
clone()

抽象类和接⼝

主要是⽤于程序架构设计

抽象类

抽象类不能实例化
抽象类中可以有抽象⽅法
抽象⽅法必须在⼦类中重写，除⾮⼦类也是⼀个抽象类
抽象⽅法只能在抽象类中
注意：
抽象类中有构造器
抽象⽅法不能是private
抽象⽅法不能是static

接⼝（旧特性 jdk1.8 之前）

接⼝⽐抽象类更加抽象

接⼝使⽤interface声明

接⼝的⼦类使⽤implements实现

接⼝中只能有抽象⽅法和静态常量

写任意的属性都默认是静态常量

写任意的⽅法默认都是抽象⽅法

接⼝可以多实现，⼀个类可以实现任意多个接⼝，当然必须实现这些接⼝中的抽象⽅法,除⾮这个类是⼀个抽象类

接⼝和接⼝之间使⽤extends继承
如果⼀个类实现的⽗接⼝之上还有接⼝，那么就必须实现接⼝中全部的⽅法

内部类

一个Java文件中可以写多个类，但是一定要注意，这个不是内部类，这种写法也不可用，而且需要注意，如果在一个类中直接写多个类，但是只有一个类中直接写多个类，但是只能有一个类可以被public修饰，而且是和文件名一样的类使用public修饰

内部类的四种写法：

成员内部类

在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量

public class OuterClass{
    private class InnerClass{
       
    }
}

在内部类中可以随意使用外部类的成员方法及成员变量，尽管被修饰为private

匿名内部类

class OuterClass{
    Public Outlnterface doit(){        //定义doit()方法
        return new OutLnterface(){     //声明匿名内部类
            private int i = 0;
            public int getValue(){
                return i;
            }
        };
    }
}

doit()方法内部首先返回一个OutInterface的引用，在return语句中插入一个定义内部类的代码，由于这个类没有名称，所以称之为匿名内部类。

静态内部类

在内部类前添加修饰符static，

不可以使用外部类的非静态成员

局部内部类

所在类的私有成员变量

public class OuterClass{
    private class InnerClass{
       
    }
}

在内部类中可以随意使用外部类的成员方法及成员变量，尽管被修饰为private

匿名内部类

class OuterClass{
    Public Outlnterface doit(){        //定义doit()方法
        return new OutLnterface(){     //声明匿名内部类
            private int i = 0;
            public int getValue(){
                return i;
            }
        };
    }
}

doit()方法内部首先返回一个OutInterface的引用，在return语句中插入一个定义内部类的代码，由于这个类没有名称，所以称之为匿名内部类。

静态内部类

在内部类前添加修饰符static，

不可以使用外部类的非静态成员

局部内部类