java面向对象，final，super ，抽象类，重写，代码块，static，this，构造方法，堆栈

Posted 2020-12-27 lizhioeng

在jvm内存中主要分布有以下三个区域：

　　　　栈：存放基础数据和自定义对象的引用

　　　　堆：主要存储创建的对象，即new出来的对象

　　　　方法区：加载存放class文件（字节码文件）

 

什么是封装？
封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装的优点：
隐藏代码的实现细节，提高安全性。

 

 private 私有属性：（调用属性先执行提供的get或set方法）

私有属性：

class Person {
    
    //姓名
    private String name;

    //年龄
    private int age;

    //对外提供公共的访问方式，编写set和get方法
    public void setAge(int _age){
        if(_age>0 && _age < 120){
            age = _age;
        }else{
            System.out.println("年龄不符合常理，请重新设置！");
        }
        
    }
    public int getAge(){

        return age;
    }


    public void setName(String _name){
        name = _name;
    }
    public String getName(){
        
        return name;
    }
}

View Code

 

基本数据类型的参数传递，值传递：（值不会受到影响）

 

/*
    基本数据类型的参数传递，值传递
*/
public class ParamTest01{
    
    public static void m1(int i){
        
        i = i + 1;
        System.out.println("m1方法中的i=" + i);//11
        
    }

    public static void main(String[] args){
    
        int i = 10;
        m1(i);
        System.out.println("main方法中的i=" + i);//10
    }
}

 

 

 

引用数据类型传递，传递的是引用传递（值会改变）

/*
    引用数据类型的参数传递，传递的引用，引用传递
*/
public class AnimalTest01 {

    public static void m1(Animal a){
        int age = a.getAge();
        a.setAge(++age);
        System.out.println("m1方法中的age=" + a.getAge());//11

    }

    public static void main(String[] args) {
        
        Animal a = new Animal();
        a.setAge(10);
        m1(a);
        System.out.println("main方法中的age=" + a.getAge());//11

    }
}

 

构造方法：

对象被创建时会执行

构造方法（constructor），有的地方叫做构造器或者构造函数。
　　　　构造方法的作用是给对象数据进行初始化。

构造方法格式特点
　　　　1.方法名与类名相同(注意大小写也要与类名一致)
　　　　2.没有返回值类型
　　　　3.没有void修饰
　　　　4.没有具体的返回值return;
　　　　5.如果一个类没有提供任何构造方法，系统默认提供无参数构造方法
　　　　6.如果一个类已经手动的提供了构造方法，那么系统不会再提供任何构造方法。

定义构造方法

class User{
    
    private String name;
    private int age;
    
    //构造方法，最好手动编写一个无参的构造方法
    public User(){
        
        System.out.println("构造方法");
    }

    public User(String _name, int _age){
        name = _name;
        age = _age;
    }

    public String getName(){
        return name;
    }
    public void setName(String _name){
        name = _name;
    }

    public int getAge(){
        return age;
    }
    public void setAge(int _age){
        age = _age;
    }
}

View Code

调用

public class UserTest01 {
    public static void main(String[] args) {
        
        User u = new User();
        //u.User();不能手动调用构造方法
        /*
        User u = new User("赵六",20);
        System.out.println(u.getName());
        System.out.println(u.getAge());
        */
    }
}

View Code

通过this  关键字（指代当前类）      实例对象调时  值显示对象传入的值 （注意：java中就存在近原则）

实例View Code

 

static（修饰类的变量，和对象没有关系）

可以修饰变量，被static修饰的变量叫做静态变量，
程序运行时静态变量存放在方法区里面，因此，静态变量在类加载阶段赋值，并且只赋值一次。

class Employee{

    private String name;
    
    static String company = "阿里巴巴";

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


public class StaticTest01 {

    public static void main(String[] args){
        Employee e = new Employee();
        System.out.println(e.company);//开发中不建议这样使用
        e = null;
        System.out.println(e.company);//不报错，static修饰的变量跟对象没有关系
        System.out.println(Employee.company);//开发中建议这样写，使用类名.静态变量名的方式访问静态变量
        
    }

}

View Code

 

static可以修饰方法，被static修饰的方法叫做静态方法，（修饰方法，和对象没有关系）
不用创建对象就能能直接访问该方法，即使用类名.静态方法名的方式。
静态方法不能访问非静态的数据（调用非静态方法也不可以），静态方法不能使用this。

public class StaticTest02{
    
    int i;

    public void m1(){
        System.out.println("m1方法");
    }
    
    public static void m2(){
        //m1();//error静态方法不能引用非静态方法
        //System.out.println(i);//error静态方法不能引用非静态变量
        System.out.println("静态方法m2");
    }

    public static void main(String[] args){
        
        StaticTest02 st = new StaticTest02();
        st.m1();
        m2();//静态方法可以直接调用静态方法
        StaticTest02.m2();//开发中建议这样使用
        st = null;
        st.m2();//开发中不建议这样使用，静态方法跟对象无关
    }

}

View Code

 

static可以定义静态语句块，静态语句块在类加载阶段执行，并且只执行一次，并且是自上而下的顺序执行，在构造方法之前执行。

public class StaticTest03{
    //静态语句块中的内容只会执行一次
    static{
        System.out.println("静态语句块1");
    }

    static{
        System.out.println("静态语句块2");
    }
    
    static{
        System.out.println("静态语句块3");
    }
    public StaticTest03(){
    
        System.out.println("构造方法");
    }
    public static void main(String[] args){
        
        System.out.println("main方法1");
        System.out.println("main方法2");
        new StaticTest03();
        new StaticTest03();
    }

}

View Code

 

代码块

局部代码块，在方法中出现，限定变量生命周期，及早释放，提高内存利用率
构造代码块，在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
静态代码块， 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。一般用于加载驱动。
同步代码块(后面多线程部分会讲解)

public class BlockTest01  {
    public static void main(String[] args) {
        //局部代码块
        {
            int x = 10;
            System.out.println(x);
        }    
        //System.out.println(x);

        Student s1 = new Student();
        System.out.println("------------");
        Student s2 = new Student();
    }

    static{
        System.out.println("BlockTest01中的静态代码块");
    }
}

class Student {

    public Student(){

        System.out.println("构造方法");
    }    
    
    //构造代码块
    {
        System.out.println("构造代码块");
    }
    
    static{
        System.out.println("静态代码块");
    }

View Code

先执行静态代码块  局部代码块  构造代码  构造方法

 

 

继承：extends

子类不能访问父类中private修饰的方法

public class Test01 {
    public static void main(String[] args) {
        SubClass s = new SubClass();
        s.m1();
        //s.m2();//error子类不能访问父类中private修饰的方法
        s.m3();
        s.m0();//子类可以访问到其祖先类的方法
    }
}

重写，也叫做覆盖，当父类中的方法无法满足子类需求时，子类可以将父类的方法进行重写编写来满足需求。比如孩子继承了父亲的房子，可以将房子重新装修。
方法重写的条件：

• 两个类必须是继承关系
• 必须具有相同的方法名，相同的返回值类型，相同的参数列表.
• 重写的方法不能比被重写的方法拥有更低的访问权限。
• 重写的方法不能比被重写的方法抛出更宽泛的异常。
• 私有的方法不能被重写。
• 构造方法无法被重写，因为构造方法无法被继承。
• 静态的方法不存在重写。
• 重写指的是成员方法，和成员变量无关。

 

super 关键字  调用父类方法 或 变量

public class Dog extends Animal {
    public String name = "旺财";

    public void eat(){
    
        System.out.println("吃狗粮");
    }

    public Dog(){
        //super("土豪金","藏獒");super()
        System.out.println("Dog中的无参构造方法");
    }

    public void m1(){
        System.out.println(super.name);
        System.out.println(this.name);//可以不加this
        super.eat();
        this.eat();//可以不加this
    }
}

 

多态：  不同实例调用相同方法时返回值却不相同

public class AnimalTest01 {
    public static void main(String[] args) {
        Cat c1 = new Cat();
        c1.eat();

        Animal a1 = new Cat();//父类引用指向子类对象，自动类型转换，也叫做向上转型
        a1.eat();//动态绑定和静态绑定
        //System.out.println(a1.num);//结果10，说明成员变量不存在重写
        //a1.move();

        Cat c2 = (Cat)a1;//强制类型转换，也叫做向下转型
        c2.move();

        Animal a2 = new Dog();
        if(a2 instanceof Cat){
            Cat c4 = (Cat)a2;    
        }else{
            System.out.println("a2不是Cat类型");
        }
        //Cat c3 = (Cat)a2;//error ClassCastException类转型错误
    }
}

View Code

成员变量不存在重写

 

final：

　　　　final修饰的类无法被继承。
　　　　final修饰的方法无法被重写。
　　　　final修饰的局部变量，一旦赋值，不可再改变。
　　　　final修饰的成员变量必须初始化值。

public class FinalTest01{

    public final int k = 10;
    
    //常量，标识符大写
    public static final double PI = 3.14;

    public static void main(String[] args){
        /*
        final int i = 10;
        i = 20;
        */
    }
}

final修饰的基本数据类型，值不能改变
final修饰的引用数据类型，指向地址是不能改变的，但是对象里面的值是可以改变的

抽象类：abstract

 

public abstract class A{

    public A(){
    
        System.out.println("class A");
    }
    
    //抽象方法
    public abstract void m1();

    public static void main(String[] args){
        //A a = new A();//抽象类不能被实例化
        A a = new B();
        a.m1();
    }
}

class B extends A{

    public void m1(){
        System.out.println("class B中的m1方法");
    }

    public B(){
        super();
        System.out.println("class B");
    }
}