JavaSE知识点总结(二)

第九章 面向对象思想

java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想。面向对象是相对于面向过程来说的

面向对象思想总结:
1.面向过程:当要实现一个功能时,需要亲力亲为,处理每个细节
2.面向对象:当要实现一个功能时,不关心具体的实现步骤,只关心结果,找一个具有该功能的类,帮我们做事
3.面向对象的思想
(1)面向对象是基于面向过程的编程思想.
(2)面向过程:强调的是每一个功能的步骤
(3)面向对象:强调的是对象,然后由对象去调用功能
4.特点
(1)是一种更符合我们思考习惯的思想
(2)可以将复杂的事情简单化
(3)角色发生了转换,将我们从执行者变成了指挥者

类和对象

• 类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物、
• 属性：对应于类中的成员变量
• 行为：对应于类中的方法
• 对象：是一类事物的具体体现，对象是类的一个实例，必然具备该类事物的属性和行为
• 类和对象的关系：类是对一类事物的描述，是抽象的，对象是一类事物的实例，是具体的

成员变量和局部变量

public class Animal{
    String name;//--->成员变量
    public void eat(){
        String num;//--->局部变量
        System.out.println("大口大口的吃");
    }
}

局部变量和成员变量的区别
1.在类中的位置不同
成员变量：类中，方法外
局部变量：方法中或者方法声明上(形式参数)
2.在内存中的位置不同
成员变量：堆内存
局部变量：栈内存
3.生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
4.初始化值的不同
成员变量：有默认值
局部变量：没有默认值。必须先定义，赋值，最后使用
5.作用范围不一样
成员变量：类中
局部变量：方法中

第十章 封装

封装可以认为是一种屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据必须要通过制定的形式，适当的封装有利于代码的理解和维护，代码也更加安全。

原则：将属性隐藏起来，若要访问某个属性，提供公共方法对其访问

使用关键字private修饰成员变量是实现封装的一种形式，被private修饰的成员变量和方法只有在本类中才能进行访问。

this关键字

this代表所在类的当前对象的引用（地址值），即对象自己的引用。

方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

构造方法

当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void。

无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。

JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean 的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的set 和get 方法。

第十一章 继承

概念1：定义一个类时，发现已有类与要定义的类似相似，并且要定义的类属于已有类的一种时，可以将要定义的类定义为已有类的子类。

概念2：多个类有共性内容，可以将共性内容向上抽取，抽取到一个新的类中，新的类和多个类形成的关系叫做继承

方法重写

当子类继承父类之后，可以直接使用父类非私有的内容，但如果子类觉得父类的方法不够强大，可以按照自身的逻辑重写此方法，这叫做方法的重写，方法覆盖

注意事项

• 可以使用@Override来验证是否重写方法

• 子类方法的访问权限必须大于等于父类的访问权限

• 如果方法的返回值类型时基本类型，必须一致

  ​ 如果方法的返回值类型是引用类型，可以一致，

  ​ 也可能是父类方法的返回值类型是子类重写方法的返回值类型的父类

this和super

this:当前对象的引用

super：当前对象的父类的引用

this.成员变量------>当前对象的成员变量

super.成员变量------>当前对象的父类的成员变量

注意：当this和super访问构造方法时，必须在构造方法的第一行进行使用，有this()就没有super()

继承的特点

• java只支持单继承，不支持多继承
• java支持多层继承
• 所有的类都直接或间接继承自Object类

第十二章 抽象类

在面向对象的概念中，所有的对象都是通过类来描述的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象外，类的其他功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

抽象类规定了这一类事物应该具备的属性和功能

1、抽象方法：没有方法体的方法

2、抽象类：包含抽象方法的类

3、abstract使用：用abstract关键字修饰的方法就是抽象方法，抽象方法只包含一个方法名，而没有方法体

4、抽象累的使用

• 定义抽象类
• 定义子类继承抽象类
• 重写抽象方法
• 创建子类对象 调用方法

tips:任何引用父类的地方，都可以传入其子类对象

第十三章 final关键字

• final:不可改变。可以修饰类、方法、变量

  • 类：被final修饰的类，不能被继承
  • 方法：被final修饰的方法，不能被重写
  • 变量：被final修饰的变量，不能被重写赋值

• 注意事项

  • final修饰引用数据类型，地址值不能改变，属性值可以改变
  • final修饰成员变量，不能使用默认值，必须在创建对象之前赋值

第十四章 接口

接口(Interface)，是java语言中一种引用数据类型，是抽象方法的集合，接口通常用Interface来声明。类通过实现接口的方式，从而实现接口的抽象方法。

接口并不是类，编写接口的方式和类相似，但它们属于不同的概念。类描述对象的属性和方法，接口中则包含类要实现的方法。

定义格式

public interface 接口名称{
	//抽象方法
}

接口的使用

当类实现接口的时候，类要实现接口中所有的方法，否则，必须声明为抽象类，类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面

public class 类名 implements 接口{
    重写抽象方法
} 

接口的成员的特点

在接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰

public interface Animal{
    int NUM;//错误，必须赋值
    int NUM1=10;//正确，
    public static final int NUM2= 100; // 正确 , 完整写法
}

成员方法 固定修饰符修饰 public abstract

public interface Animal{
     void method(); //正确 没写public abstract java自动补齐
  public abstract void method2();//正确 完成写法
  public void method3(); //正确 没写abstract  java自动补齐
  private void method4();// 错误 
  public void method5(){} //错误 接口中都是抽象方法
}

接口中没有构造方法，不能直接创建对象

public interface LiveAble{
  	public LiveAble(){} //错误 接口没有构造方法
}

接口的特点

• 类与类是继承关系，不能多继承

  类与接口是实现关系，可以单实现，也可以多实现

• 类可以在继承一个类的同时，实现多个接口

• 接口和接口是继承关系，可以单继承也可以多继承

• 接口没有构造方法

接口和抽象类的区别

成员上的区别

成员变量：

接口的成员变量都是常量

抽象类的成员变量可以是常量也可以是变量

成员方法：

接口中的成员方法都是抽象方法

抽象类中的成员方法既可以是抽象的，也可以是具体的

构造方法：

接口没有构造方法

抽象类有构造方法

思想上的区别

接口描述的是体系外额外的功能

抽象类描述的是一类事物最基本的属性和行为

第十五章 多态

多态是同一个行为具有多个不同表现形式或形态的能力

多态就是同一个接口，使用不同的实例而执行不同操作

多态性就是对象多种表现形式的提现

多态的前提条件：

• 继承或者实现
• 父类引用指向其子类对象

多态的格式

父类类型 变量名=new 子类类型()

public class Animal{}
public class Dog extends Animal{}
public class Cat extends Animal{}
public class Test{
    public static void main(String[] args){
        Animal animal=null;//animal是Animal类型的，既可以用Dog子类对其赋值，也可以用Cat子类对其赋值
        animal = new Dog();
        animal = new Cat();
    }
}

多态后访问成员特点

成员变量

编译时：会在父类中查看是否有这个变量，有则通过编译，没有则编译报错。

运行时：打印的是父类成员变量的值

编译看左边，运行也看左边

public class Animal{
    String name="小白";
}
public class Dog extends Animal{
    String name="小黑"
    int age=10;
}
public class Test{
    public static void main(String[] args){
        Animal animal=new Dog();
        //animal.age=20;//------>编译报错 编译时查看父类Animal没有找到age这个属性
        System.out.println(animal.name);//打印 小白 运行时打印的是父类的成员变量
    }
}

成员方法

编译时：在父类中查看是否有这个方法的声明，有则通过编译，没有则编译报错

运行时：运行时若子类重写了父类方法，则运行子类重写之后的方法

编译看左边，运行看右边

public class Animal{
    public void fun(){
        System.out.println("父类的方法");
    }
}
public class Dog extends Animal{
    public void fun(){
        System.out.println("子类的方法");
    }
}
public class Test{
    public static void main(String[] args){
        Animal animal=new Dog();
        animal.fun();//打印  子类的方法 
    }
}

向上转型

多态本身就是向上转换

Animal animal = new Dog();

向下转型

类似强制转换

Animal animal = new Dog();
Dog dog=(Dog)animal;

可以用关键字instanceof 来判断某个对象是否属于某种类型 如果属于返回true，如果不属于返回false