[Java知识库] java入门总结---第四部分：三大特性、三个修饰符、接口

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> java入门总结---第四部分：三大特性、三个修饰符、接口 -> 正文阅读

[Java知识库]java入门总结---第四部分：三大特性、三个修饰符、接口

一、三大特性（重点）

1、封装（private）

封装的必要性：在对象的外部为对象的属性赋值，可能存在非法数据的录入，存在不安全隐患。
概念：尽可能隐藏对象的内部实现细节，控制对象的修改及访问权限

在这里插入图片描述

为属性赋值(修改属性值)：set方法

public void set属性名(数据类型 变量名){
	this.属性名 = 变量名;
}

获取属性的值：get方法

public 数据类型 get属性名(){
	return this.属性名;
}

注意：属性名首字母大写

public class function {
    public static void main(String[] args) {
        myPrivate myPrivate = new myPrivate();
        myPrivate.sex = "男";
        myPrivate.i = 10;
        //myPrivate.name = "罗";    ！编译错误！
        myPrivate.setName("罗");    //可以编译
    }
}
class myPrivate{
    private String name;
    private int age;
    String sex;
    int i;
    
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
}

2、继承（基础重点）

继承，生活中的继承有儿子继承父亲的资产。而程序的继承，是类与类之间特征和行为的一中赠与或获得。好比，所有生物都会呼吸，而动物类也都会呼吸，动物类就可以继承生物类的呼吸特征；人类会走路，老年人也是会走路的，所以定义的老年人类就可以继承人类的走路行为。

（1）、基本了解

//语法
class 子类类名 extends 父类类名{
	
}

继承是一种机制，通过继承机制可以让子类直接使用父类中属性和方法
继承的好处：体现代码的可复用性和可扩展性。
java的继承是单继承，即一个类只能有一个直接的父类，但可以多级继承

（2）、方法的覆盖(override)（重写）
当父类提供的方法无法满足子类需求时，可在子类中定义和父类相同的方法进行覆盖（Override）

方法的覆盖原则：
1、方法名称、参数列表、返回值类型必须与父类相同
2、访问修饰符可与父类相同或是比父类更宽泛
3、子类覆盖父类方法后，调用时优先执行子类覆盖后的方法
方法覆盖的执行：子类对象名.方法名(实参);

（3）、super（重点）

第一种用法：
在子类的方法中使用“super.”的形式访问父类的属性和方法
例如

super.父类属性、super.父类方法();

第二种用法
在子类的构造方法的首行，使用“super()”或“super(参数)”，调用父类构造方法

super的访问方法

public class textSuper {
    public static void main(String[] args) {
        mySon myson = new mySon();
        myson.function();//结果输出：罗是好人
    }
}
class mySon extends Father{
    @Override
    public void function() {//进行重写
        super.function();//super.父类方法();进行访问方法
    }
}
class Father extends Object{
    public void function(){
        System.out.println("罗是好人");
    }
}

！！注意！！

super 不能使用在静态（static）方法中。
super. 大部分情况下是可以省略的。
super.什么时候不能省略：父中有，子中又有，如果想在子中访问“父的特征”，super. 不能省略。在父和子中有同名的属性，或者说有相同的方法，如果此时想在子类中访问父中的数据，必须使用“super.”加以区分。

super的访问属性

public class textSuper{
	public static void main(String[] args){
		mySon myson = new mySon();
		myson.function();
}
class mySon extends father{
	int vai = 10;
	public void function(){
        int i = 20;
        System.out.println(i);//20
        System.out.println(this.i);//10
        System.out.println(super.i);//30-----super进行访问属性，输出30
    } 
}
class father{
	int vai = 30;
}
}

3、多态

（1）、概念：父类引用指向子类对象，从而产生多种形态

父类型 引用名 = new 子类类名(实参);

如果用父类型的引用调用属性和方法，只能调用父类中声明的属性和方法;
运行时，JVM自动检测子类是否覆盖父类中方法，如果子类覆盖了父类中方法，则运行覆盖之后的方法，否则直接运行父类中方法。

（2）、多态的应用
? ① 多态应用在数组上：本类型+所有子类型的对象都可以作为数组元素存储
? ② 多态应用在形式参数上：本类型+所有的子类型都可以作为实际参数进行传递
? ③ 多态应用在返回值上：本类型+所有的子类型都可以作为返回值返回。

4、拆箱装箱

向上转型（装箱）

public class textOut{
	public static void main(String[] args){
		Animal a = new Dog();
		a.eat();//输出：doy,向上转型
	}
class Doy extends Animal{
	public void eat(){
        System.out.println("doy");
    }
}
class Animal{
	public void eat(){
    	System.out.println("Animal");
    }
}
}

向下转型（拆箱）

public class textOut{
	public static void main(String[] args){
		Animal a = new Dog();
		Dog dog = (Dog)a;//向上转型
	}
class Doy extends Animal{
	public void eat(){
        System.out.println("doy");
    }
}
class Animal{
	public void eat(){
    	System.out.println("Animal");
    }
}
}

二、三个修饰符

1、abstract(抽象的)

(1)、abstract修饰类

abstract修饰类，此类不能new对象，但是可以声明引用。强制使用多态。
被abstract修饰的类称为抽象类

abstract class 类名{}

！子类继承抽象类后，必须覆盖父类所有的抽象方法，否则子类也必须是抽象类！

public class textAbstr{
public static void main(String[] args){
		Animal1 a1 = new Doy1();
        Animal1 a2 = new Cat1();
}
abstract class Animal1{
    public Animal1(){}

    public void eat(){
        System.out.println("Animal1 eat");
    }
    public void sleep(){
        System.out.println("Animal1 sleep");
    }
}
class Doy1 extends Animal1{ }
class Cat1 extends Animal1{ }
}

(2)、abstract修饰方法
①被abstract修饰的方法称为抽象方法。
? ② 抽象方法只有方法的声明部分，没有实现部分(连{}都没有)
? ③ 注意：抽象方法只能定义在抽象类中；抽象类中可以定义抽象方法和非抽象方法。
? ④ 子类继承抽象类，如果子类不想成为抽象，则需要覆盖父类中所有的抽象方法，否则子类也必须定义为抽象类。

访问修饰符 abstract 返回值类型 方法名(形参);

abstract class Animal1{
	public abstract void sleep();
}

2、static（静止的）

静态（static）可以修饰属性和方法

（1）、静态属性使用

位置：定义在类以内，方法以外,被static修饰

//语法使用
访问修饰符 static 数据类型 属性名;
public static int i;
使用：类名.静态属性名
classname.i

public class textname{
	public static void main(String[] args){
		myName myname = new myName();
		myname.i = 10;
		System.out.println(myname.i);//结果：10    使用：类名.静态属性名
}
class myName{
	public static int i;
}

}

静态属性的特点：类变量，和创建多少对象无关，全类共有。

public class textStatic {
    public static void main(String[] args) {
        myStatic myStatic1 = new myStatic();
        myStatic1.b = 10;
        myStatic myStatic2 = new myStatic();
        myStatic2.b = 20;
        System.out.println(myStatic1.b+myStatic2.b);//结果：30
    }
}
class myStatic{
    static int b;
}

（2）、静态方法使用

位置：定义在类以内，其他方法以外，被 static修饰

//语法使用
访问修饰符 static 返回值类型 方法名(形参){}
public static void me(){}
使用：类名.静态方法名(实参); //建议使用
classname.me();

public class textFunc{
	public static void main(String[] args){
		myStaticFunc.me();//结果：你好
	}
class myStaticFunc{
	public static void me(){
		System.out.println("你好");
	}
}
}

在同类中写方法名即可

public class textFunc{
	public static void main(String[] args){
		me();//结果：你好
}	public static void me(){
		System.out.println("你好");
	}
}

静态的特点

静态方法允许直接访问静态成员
静态方法不能直接访问非静态成员
静态方法中不允许使用this或是super关键字
静态方法可以继承，但不能重写、没有多态

（3）、静态代码块使用

位置：定义在类以内，方法以外 {}
作用：创建对象时，按照和属性定义的先后顺序，完成对属性的初始化工作(在创建对象的第二个过程初始化属性时执行).

public class textStatic{
	public static void main(String[] args){
		myStatic.methrod();//结果：两个你好
	}
class myStatic{
	static String name = "你好";
	static {
		System.out.println(name);
		System.out.println("你好");
	}
}
public static void methrod(){}//为了引发代码块的使用
}

static总结

static修饰的成员为静态成员，无需创建对象，可直接通过类名访问
静态方法不能直接访问非静态成员
静态方法中不能使用this或super
静态方法可以继承，但是不能重写、没有多态
静态代码块在类加载时被执行，且只执行一次

1、final(最终的、不可更改的)

final类、final方法、final变量

final修饰类：此类不能被继承。String、Math、System均为final修饰的类，不能被继承！
final修饰方法：此方法不能被覆盖，意为最终方法。
final修饰变量：此变量值不能被改变（常量）

1、final修饰类：此类不能被继承
2、final修饰方法：此方法不能被覆盖
3、final修饰变量：此变量值不能被改变（无初始值，只允许赋值一次）

局部变量：显示初始化
实例变量：实现初始化、动态代码快、构造方法
静态常量：显示初始化、静态代码块
基本数据类型常量：值不可变
引用数据类型常量：地址不可变

三、接口

概念：接口是一种标准，是接口的使用者和接口的实现者之间的约定。

接口的定义：代表了某种能力
方法的定义：能力的具体要求

关键字：interface

//语法
interface 接口名{}

经验： Java为单继承，当父类的方法和无法满足子类需求时，可以实现接口扩充子类能力

class father{···}
interface Running{···}
class son extends father interface Running{···}

注意点：
①接口不能创建对象，但是可以声明引用
② 接口中没有构造方法
③ 接口中的属性都是公开、静态、常量(默认的被 public static final 修饰)
④ 接口中的方法都是公开、抽象的(默认的被 public abstract修饰)
⑤接口不是类

public class myInterface{
    public static void main(String[] args) {
        son son = new son();
        father a = myson;
        sleep s = myson;
        Running r = myson;
        
    }
}
interface sleep{
    public abstract void sleep();
}
interface Running{
    public abstract void running();
}
class father{
    public void eat(){}
    public void word(){}
}
class son extends father interface sleep,Running{
    public void sleep(){}
    public void running(){}
    public void func(){}
}