Java入门之面向对象小结

package oop;

public class OopTest {
    public static void main(String[] args) {
        Phone p = new Phone();
        p.call();
        p.message();
        p.learn();

        System.out.println(p.brand);//null
        System.out.println(p.price);//0.0
        System.out.println(p.size);//0.0
        System.out.println(p.color);//null
        //以下为匿名对象，其实我更喜欢这么写 0.0
        new Phone().call();
        new Phone().learn();
        new Phone().message();

        System.out.println(new Phone().brand);
        System.out.println(new Phone().price);
        System.out.println(new Phone().size);
        System.out.println(new Phone().color);


    }
}


class Phone{
    //特征(属性)--类的成员变量来描述--位置:类里方法外
    String brand;//品牌
    double price;//价格
    double size;//尺寸
    String color;//颜色

    //行为(功能)--类的方法来描述--修饰符 返回值类型 方法名(参数列表){方法体}
    public void call() {
        System.out.println("正在打电话");
    }
    public void message() {
        System.out.println("正在发短信");
    }
    public void learn() {
        System.out.println("正在看直播");
    }
}

 属性封装后无法直接查看和修改，需要generate Getter() and Setter().也可以用构造方法修改

//封装
private String brand;
//第一种更改和查看方法
p.setBrand("Huawei");
System.out.println(p.getBrand());
//第二种更改方法，生成一个带参数的构造方法
public Phone(String brand) {
    this.brand = brand;
}
Phone p = new Phone("Huawei");
//或者这样写
System.out.println(new Phone("Huawei").getBrand());

访问控制符：

Phone p = new Phone();
new Phone();//都会调用无参构造

Phone p = new Phone("Huawei");
new Phone("Huawei");//调用含参构造


new Phone().call();//先去调用无参构造，再执行call（）方法

1. 位置: 在类的内部,在方法的外部
2. 作用: 用于抽取构造方法中的共性代码
3. 执行时机: 每次调用构造方法前都会调用构造代码块
4. 注意事项: 构造代码块优先于构造方法加载

1. 位置: 在方法里面的代码块
2. 作用: 通常用于控制变量的作用范围,出了花括号就失效
3. 注意事项: 变量的作用范围越小越好,成员变量会存在线程安全的问题

 注意执行顺序：构造代码块->构造方法->普通方法->局部代码块

new Phone().call();

1.执行构造代码块2.执行无参构造3.执行方法4.执行局部代码块

功能1.调用本类中的成员变量

功能2.this（），用于构造方法中，调用无参或者含参构造，注意不能用于普通方法。

继承是面向对象最显著的一个特征
继承是从已有的类中派生出新的类,新类能吸收已有类的数据属性和行为,并扩展新的能力.
Java继承是会用已存在的类的定义作为基础建立新类的技术
新类的定义可以增加新的数据或者新的功能,也可以使用父类的功能,但不能选择性的继承父类(超类/基类)
这种继承使得复用以前的代码非常容易,能够大大的缩短开发的周期,降低开发费用.

1.相当于子类把父类的功能复制了一份
2.Java只支持单继承
3.继承可以传递(爷爷/儿子/孙子这样的关系)
4.父类的私有成员也会被继承，但由于私有限制访问，所以子类不能使用父类的私有资源
5.继承多用于功能的修改,子类可以在拥有父类功能的同时,进行功能拓展

1.super.xx -->父类的成员变量

2.子类的构造函数默认有super（）；

package oop;

public class OopTest {
    public static void main(String[] args) {
        new Phone().call();
        System.out.println("****");
        new Iphone().call();
    }
}
class Phone{
    static {
        System.out.println("静态代码块");
    }
    static double price;//价格
    double size;//尺寸
    String color;//颜色
    {
        System.out.println("我是一个构造代码块");
    }
    public Phone(){
        System.out.println("父类无参构造");
    }
    public void call() {
        System.out.println("正在打电话");
        {
            System.out.println("我是一个局部代码块");
       }
    }
}
class Iphone extends Phone{
    public Iphone(){
        //super();
        System.out.println("子类无参构造");
    }
//    public void call(){
//        System.out.println("子类打电话");
//    }
}

 执行结果：

 ****补充一道多态题目，求输出值

package oop;

public class Test {
    public static void main(String[] args) {
        base b = new Sub();
    }
}
class base {
    private String baseName = "base";

    public base() {
        callName();
    }

    public void callName() {
        System.out.println(baseName);
    }
}
class Sub extends base
    {
        private String baseName = "sub";
        public void callName()
        {
            System. out. println (baseName) ;
        }
    }

null 

1.static可以修饰成员变量和方法
2.被static修饰的资源称为静态资源
3.静态资源随着类的加载而加载，最先加载，优先于对象进行加载
4.静态资源可以通过类名直接调用，也被称作类资源
5.静态被全局所有对象共享，值只有一份
6.静态资源只能调用静态资源，普通资源可以调用静态资源
7.静态区域内不允许使用this与super关键字

static double price;//价格
//不用new对象 可以直接加载
System.out.println(Phone.price);

静态资源随着类的加载而加载，并且只被加载一次，一般用于项目的初始化
特点: 被static修饰,位置在类里方法外

1. 静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化
2. 构造代码块：在创建对象时会自动调用，每次创建对象都会被调用，提取构造共性
3. 局部代码块：方法里的代码块,限制局部变量的范围

特点
被final修饰的类，不能被继承
被final修饰的方法，不能被重写
被final修饰的字段是个常量，值不能被修改
常量的定义形式：final 数据类型 常量名 = 值