Java培训参考笔记：面向对象

B站录像地址

B站录像地址

复习之前的知识

配置jdk，安装Idea和新建项目跳过。

第一个Java程序：Hello World

public class HelloWorld{
	public static void main(String[] args){
		System.out.plantln("Hello World");
	}
}

Java中的变量

int a;
float b;
double c;
char d;
String e;//String是引用变量，因为很常用所以写在这里
boolean f;

Java中的输入语句

使用Java中的输入需要导入util中的Scnner

import java.util.Scanner;

建立一个Scanner类的对象

Scanner scanner = new Scanner(System.in);

常用输入

 a = scanner.next();
 b = scanner.nextInt();

Java运算符

注释

为了方便程序的阅读，Java语言允许程序员在程序中写上一些说明性的文字，用来提高程序的可读性，这些文字性的说明就称为注释。注释不会出现在字节码文件中，即Java编译器编译时会跳过注释语句。在Java中根据注释的功能不同，主要分为单行注释、多行注释和文档注释。

单行注释:使用’/‘开头，’/'后面的单行内容均为注释。
多行注释:以"/“开头以”/“结尾，在”/“和”/“之间的内容为注释，我们也可以使用多行注释作为行内注释。但是在使用时要注意，多行注释不能嵌套使用。
文档注释:以”//**“开头以”*/"结尾，注释中包含一些说明性的文字及一些JavaDoc标签(后期写项目时，可以生成项目的API)

流程控制

条件判断

Java条件判断语句有if switch 和三目

if(Boolean值){
	值为true时执行的语句;
}else if(Boolean){

}else{

}

switch(变量){
	case 常量1:
	break;
	case 常量2:
	break;
}

变量 = 条件判断语句?true的值：false的值;

循环

for循环，while循环，do while循环
略略略

Java类和对象

类和对象

• 对象：对象是类的一个实例，有状态和行为。
  例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
• 类：类是一个模板，它描述一类对象的行为和状态。

创建类的语法

class 类名{
	
}

实例化对象的语法

类名 对象名 = new 类名();

属性和方法

用来描述具体某个对象的特征的是属性，类的属性就是抽象化的属性。
方法是类的行为

构造方法

构造方法是和类同名的一个方法，没有返回类型，可以加修饰符，构造方法可以有参数
构造方法在创建类的对象的时候会被执行

public class LapTop {
    public LapTop(){
        System.out.println("执行了无参构造器");
    }
    public LapTop(int a){
        System.out.println("执行了LapTop中的有参构造方法");
        System.out.println("开机用了"+a+"秒");
    }
    public LapTop(String a){
        System.out.println("执行了LapTop中的有参构造方法");
        System.out.println("传入了字符串"+a);
    }
}

public class Test02 {
    public static void main(String[] args) {
        LapTop lapTop = new LapTop();
        LapTop lapTop1 = new LapTop(5);
        LapTop lapTop2 = new LapTop("开机");
    }
}

输出结果

执行了无参构造器
执行了LapTop中的有参构造方法
开机用了5秒
执行了LapTop中的有参构造方法
传入了字符串开机

Java访问修饰符

这里是引用Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

public : 对所有类可见。使用对象：类、接口、变量、方法

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

Java类的继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

类的继承格式

类继承

class 子类名 extends 父类名{

}

为什么要使用继承

• 防止代码重复过高，增加可维护性
• 增强代码的可扩展性，可重用性
• 增强代码的逻辑性

继承的特性

• 子类拥有父类非 private 的属性、方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

继承的语法

extends关键字

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

class 子类名 extends 父类名{

}

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。

public class Animal {
    public int age;
    public Double ShenChang;
    public String Name;
    public void eat(){
        System.out.println(Name+"在吃饭");
    }
    public void sleep(){
        System.out.println(Name+"在睡觉");
    }
}

class house extends Animal{
    public String Name;
    public void sleep(){
        super.sleep();
        super.Name = "xiaoA";
        this.Name = "xiaoB";
        System.out.println(super.Name+this.Name+"正在站着睡觉");
    }
}

public class Test01 {
    public static void main(String[] args) {
        house h = new house();
        h.sleep();
    }
}

输出结果

null在睡觉
xiaoAxiaoB正在站着睡觉

final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

• 声明类：

  final class 类名 {//类体}

• 声明方法

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为
final，但是实例变量并不是 final

构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
// SubClass 类继承
class SubClass extends SuperClass{
  private int n;
  
  SubClass(){ // 自动调用父类的无参数构造器
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){ 
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
// SubClass2 类继承
class SubClass2 extends SuperClass{
  private int n;
  
  SubClass2(){
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass2");
  }  
  
  public SubClass2(int n){ // 自动调用父类的无参数构造器
    System.out.println("SubClass2(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    System.out.println("------SubClass 类继承------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
    System.out.println("------SubClass2 类继承------");
    SubClass2 sc3 = new SubClass2();
    SubClass2 sc4 = new SubClass2(200); 
  }
}

Java 重写(Override)与重载(Overload)

重写(Override)

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
重写就是在子类中的和父类一样名称的方法，在实际调用中，会执行子类的方法

public class Animal {
    public int age;
    public Double ShenChang;
    public String Name;
    public void eat(){
        System.out.println(Name+"在吃饭");
    }
    public void sleep(){
        System.out.println(Name+"在睡觉");
    }
}

class house extends Animal{
    public String Name;
    public void sleep(){
        super.sleep();
        super.Name = "xiaoA";
        this.Name = "xiaoB";
        System.out.println(super.Name+this.Name+"正在站着睡觉");
    }
}

方法的重写规则

• 参数列表与被重写方法的参数列表必须完全相同。
• 返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
• 父类的成员方法只能被它的子类重写。
• 声明为 final 的方法不能被重写。
• 声明为 static 的方法不能被重写，但是能够被再次声明。
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
• 构造方法不能被重写。
• 如果不能继承一个类，则不能重写该类的方法。

Super 关键字的使用

当需要在子类中调用父类的被重写方法时，要使用 super 关键字。

public class Animal {
    public int age;
    public Double ShenChang;
    public String Name;
    public void eat(){
        System.out.println(Name+"在吃饭");
    }
    public void sleep(){
        System.out.println(Name+"在睡觉");
    }
}

class house extends Animal{
    public String Name;
    public void sleep(){
        super.sleep();
        super.Name = "xiaoA";
        this.Name = "xiaoB";
        System.out.println(super.Name+this.Name+"正在站着睡觉");//使用super调用父类属性，同理调用父类方法
    }
}

方法的重载

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。

    public void Write(){
        System.out.println("什么都没有写入");
    }
    public void Write(int a){
        System.out.println("写入了数字"+a);
    }
    public void Write(String a){
        System.out.println("写入了字符串"+a);
    }

    public LapTop(){
        System.out.println("执行了无参构造器");
    }
    public LapTop(int a){
        System.out.println("执行了LapTop中的有参构造方法");
        System.out.println("开机用了"+a+"秒");
    }
    public LapTop(String a){
        System.out.println("执行了LapTop中的有参构造方法");
        System.out.println("传入了字符串"+a);
    }

重载的规则

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。