深入理解面向对象（第一篇）

public class FinalTest01{ public static void main(String[] args) { /*
        对于局部变量，不会默认赋初始值，只要不调用，不赋初始值也能编译通过
        加上final修饰也是如此，只不过final修饰过后就不能修改了！
*/ //-----------1.局部变量正常使用和修改 int x;// 只要不调用x，编译和运行都是没问题 int i = 100;
        i = 200;
        System.out.println(i); //-----------2.用final修饰，并给变量直接赋初始值 final int y; //没问题 final int k = 10; //k = 100; //err不能在更改 System.out.println(k); //-----------3.用final修饰，给变量赋初始值的另一种方法 //先定义出来，在赋初始值，分成两步也是没问题的 final int n;
        n = 5; //n = 50;//在更改就不行了 }
} //4.final修饰的方法无法被覆盖 class C{ public final void doSome(){ //被final修饰的方法 System.out.println("C的doSome");
    }
} //err；D中的doSome()无法覆盖C中的doSome()被覆盖的方法为final class D extends C{ public void doSome(){
     System.out.println("D的doSome");
    }
 } //5.final修饰的类无法继承！ final class A{ //被final修饰，表示没有子类 } //B类继承A类，相当于A类的功能扩展；如果不希望别人继承A类；可以给A类加final关键字进行修饰 //错误：无法从A类进行继承 class B extends A{
}

public class FinalTest02 { public static void main(String[] args) { //1.-------正常使用 Person p = new Person(30);
        System.out.println(p.age);//30 //2.-------final修饰p1指向的对象不能变，p1存的是内存地址 final Person p1 = new Person(20); //和数字20没关系，只要你new就会创建一个对象，开辟新的空间，新的内存地址 p1 = new Person(20); //err；相当于把开辟出来的新空间地址，赋值给p1(本身是指向一块内存地址的) //3.-------但是对象内部的数据是可以变的 p1.age = 50;
        System.out.println(p1.age);
    }
} class Person{ int age; //构造方法 public Person() {
    } public Person(int age) { this.age = age;
    }
}

public class FinalTest03 { public static void main(String[] args) {

    }
} class User{ //1.------正常使用，就算不赋初始值，系统也会默认赋值 int age;//实例变量，系统会默认赋上默认值 int age1 = 10;//不使用系统默认值，就自己手动赋值 //2.------final修饰的实例变量，系统就不会默认赋上默认值；因为final修饰只能赋一次值； //如果赋默认值，程序员就不能再手动赋值了 final int age;//err，必须手动赋值；并且在系统默认赋值之前赋值都是可以的 //2.1.---只能手动赋上初始值；在这里赋上值，其实也是赶在系统赋默认值之前给它赋上； //所以也可以在构造方法中在赋值也是可以的!因为赋默认值是在构造方法执行的过程中 final int age1 = 0; //正确  //2.2.---也可以在无参构造方法中赋值 //在回顾一下实列变量在什么时候赋值? //构造方法执行的过程中（创建(new)对象的时候） final double weight; public User(){ //赶在系统赋默认值之前给它赋值就可以，而赋默认值是在执行构造方法执行的过程中 this.weight = 1.8; //无参构造系统默认也会给它赋上默认值；我们在它赋上默认值之前给它赋值， //也是说的通的；这样系统不会给它赋默认值了 //this.weight = 0.0;//系统赋默认值 } //weight = 1.8;//err；不借助于构造方法赋值，直接赋值也是错误的 //3.------当然也可以使用有参构造方法赋值 public User(double d){ this.weight = d;
    }
}

public class FinalTest04 { public static void main(String[] args) {
        System.out.println(Chinese.COUNTRY);//既然被static修饰，那么就用“类名.”访问 }
} class Chinese{
    String IdCard; //身份证号，每个人都不一样，对象级别的 String name;//对象级别的 //国家，固定值：“中国”；类级别的 //final修饰的实例变量必须手动赋值；并且只能赋值一次，不会改变！ //实例变量在堆中，一个对象就一份；比较浪费空间 //实例变量既然使用final修饰，说明该实例变量不会随着对象的变化而变化 //final String country = "中国"; //声明为实例变量，比较浪费空间 //既然final修饰的永远不会改变，就没必要在声明为实例变量；最好是静态的，节省空间 static final String COUNTRY = "中国";//声明为静态变量 } //常量一般都是公开的；所以家伙加上public class MyMath{ //π永远不会变，定义为常量 public static final double PI = 3.1415926;//加上public修饰，一般都是公开的 }

public class AbstractTest01 { public static void main(String[] args) { // Account是抽象的; 无法实例化；不能new对象 // Account a = new Account();//抽象类无法实例化 }
} //银行账户类---抽象类:可以有构造方法、抽象方法、非抽象方法 abstract class Account{ public Account() {//无参构造 } public Account(String s) { //有参构造 } // 非抽象方法 public void doOther(){

    } // 抽象方法 public abstract void withdraw();
} /*
class CreatAccount extends Account{
    public CreatAccount() {
        super();//无参构造默认有super()调用父类的无参构造方法
    }
}
*/ /*
//1.非法的修饰符组合: abstract和final
final abstract class Account{

}*/ /*
//2.非抽象子类继承抽象类，子类可以实例化对象
class CreatAccount extends Account{

}*/ /*
//3、抽象类的子类还可以是抽象类
abstract class CreatAccount extends Account{

}*/ 

public class AbstractTest02 { public static void main(String[] args) { //也可以使用多态：父类型引用指向子类型引用；这里是向上转型（自动类型转换） Animal a = new Bird();//这就是面向抽象编程 //a的类型是Animal，Animal是抽象的； //面向抽象编程，不要面向具体编程，降低程序的耦合性，提高程序的扩展力 //这种编程思想符合OCP原则 a.move(); //编译的时候是父类Animal的move() //运行的时候是子类Bird的move() //---练手；多态 Animal a1 = new Cat();//调用的是默认的无参构造方法 a1.move();
    }
} // 动物类（抽象类）-----------------父类 abstract class Animal{ //抽象方法 public abstract void move();
} /*err
// 子类（非抽象类）---Bird不是抽象的, 并且未覆盖Animal中的抽象方法move()
class Bird extends Animal{
}
//Animal是父类，并且是抽象的；Animals这个抽象类中有一个抽象方法move
//Bird是子类，是非抽象的；Bird继承Animals之后，会将抽象方法继承过来
*/ /*正确-------------方法重写/覆盖
class Bird extends Animal{
    //需要将从父类继承过来的抽象方法进行覆盖/重写；
    //或者也可以叫做“实现”；把抽象方法实现了
    public void move(){

    }
}*/ /*正确-------------子类写成抽象类
//如果Bird是抽象类的话，那么这个Animal中继承过来的抽象方法也可以不去重写/覆盖/实现
abstract  class Bird extends Animal{
}*/ //-----------------子类 class Bird extends Animal{ //需要将从父类继承过来的抽象方法进行覆盖/重写； //或者也可以叫做“实现”；把抽象方法实现了 public void move(){
        System.out.println("鸟儿在飞翔");
    }
} //再写一个炼手 class Cat extends Animal{ public void move(){
        System.out.println("猫儿在走猫步");
    }
}

public class InterfaceTest01 {
    public static void main(String[] args) {
        //访问接口的常量
        System.out.println(MyMath.PI);//接口也是一个类，用“接口.”调用

    }
}

//定义接口
interface A{ //生成A.class字节码文件
}
//在定义一个接口
interface B{ //生成B.class字节码文件
}
//接口支持多继承
interface C extends A,B{ //生成C.class字节码文件
}

//我的数学接口
interface MyMath1{
    //常量
    //public static final double PI = 3.1415926;
    //另一种写法：public static final可以省略
    double PI = 3.1415926;

    //抽象方法
    public abstract int sum(int x, int y);
    //另一种写法：public abstract可以省略
    int sub(int x, int y);

   /* ----就是把分号改成大括号err
   //接口中的方法不可以有方法体
    void doSome(){

    }*/
}

public class InterfaceTest02 {
    public static void main(String[] args) {

    }
}

//特殊的抽象类，完全抽象的，叫做接口
interface MyMath01{
    double PI = 3.1415926;//省略了public static final
    int sum(int a,int b);//抽象方法，省略了public abstract
    int sub(int a,int b);
}

//编写一个非抽象类去实现接口

/*
//1.err----会像继承一样把抽象方法继承过来，编译错误
class MyMathImp implements MyMath01 {

}*/

/*//2、修改方法1--用抽象类去实现接口（不常用）
abstract class MyMathImp implements MyMath01 {

}*/

//3、修改方法2---将方法进行覆盖、重写（常用）
class MyMathImp implements MyMath01 {
    public int sum(int a,int b){
        return a+b;
    }
    public int sub(int a,int b){
        return a-b;
    }

  /*//如果把public省略？我们以前讲过，继承不能让访问权限更低
  //err，正在尝试分配更低的访问权限，以前为public----抽分说明了接口中的方法都是public(公共的)
  
  //父类为public子类必须也是public，不能省略不写!
    int subb(int a,int b){
        return a-b;
    }*/

}

public class InterfaceTest03 {
    public static void main(String[] args) {
        //使用多态---父类型的引用指向子类型的对象
        Math01 m = new MathImp();
        //调用接口里面的方法（面向接口编程）
        System.out.println(m.sum(10,20));
        System.out.println(m.sub(10,20));

    }
}

//----接口
interface Math01{
    double PI = 3.1415926;//省略了public static final
    int sum(int a,int b);//抽象方法，省略了public abstract
    int sub(int a,int b);
}

//----实现
class MathImp implements Math01 {
    public int sum(int a,int b){
        return a+b;
    }
    public int sub(int a,int b){
        return a-b;
    }

}

public class InterfaceTest04 { public static void main(String[] args) { AA a = new DD(); BB b = new DD(); CC c = new DD(); //那么通过接口a能调用接口b里面的m2()吗？----通过向下转型 //这个编译没问题，运行也没问题 //调用其他接口中的方法，你需要转型（接口转型） BB b2 = (BB)a;
        b2.m2(); //-----------也可以直接转成DD DD d = (DD)a;
        d.m2(); //----------------------------------- //多态---父类型的引用指向子类型的对象 M m = new E(); //把m类型转换成K类型----实际上这两个接口与没关系 //接口和接口之间在进行强制类型转换的时候，没有继承关系，也可以强转 //但需要注意的是：运行时可能会出现ClassCastException异常 if(m instanceof K){ K k = (K)m;
        }


    }
} interface K{

} interface M{

} class E implements K,M{

} //--------------------------------------------- /*//1.---------接口与接口之间支持多继承
interface X{

}
interface Y{

}
interface Z extends X,Y{

}*/ //------------------------------------------------ //2.----------一个类可以是实现多个接口 //实现多个接口，其实就是类似于多继承 interface AA{ void m1();
} interface BB{ void m2();
} interface CC{ void m3();
} class DD implements AA,BB,CC{ //注意要把接口里面的所有方法重写，因为接口的方法都是抽象的；但这个类不是抽象的 public void m1(){

    } public void m2(){
        System.out.println("m2.......");
    } public void m3(){

    }

}

public class InterfaceTest05 { public static void main(String[] args) { // 创建对象（表面上看Animals类没起作用） Flyable f = new Cat1();//多态 f.fly(); //同一个接口，调用同一个fly()方法，最后的执行效果不同 Flyable f2 = new Pig();
        f2.fly();

    }
} //动物类：子类 class Animals{

} //接口 interface Flyable{ void fly();
} //猫类---子类 //Flyable是一个接口，是一对翅膀的接口，通过接口插到猫身上，让猫可以飞翔 class Cat1 extends Animals implements Flyable{ public void fly(){
        System.out.println("猫可以飞翔");
    }
} //假设有一个蛇类--我们不让他飞，就不实现Flyable接口 class Snak extends Animals{

} //假设有一个猪类---我们让它飞，就实现Flyable接口 class Pig extends Animals implements Flyable{ public void fly(){
        System.out.println("小猪会飞");
    }
} //假如我们不写继承Animals,默认是继承Object的 class Fish implements Flyable{ //没写extends也是有的，默认继承Object public void fly(){

    }
}

/*
Cat is a Animal 但凡满足is a的表示都可以设置为继承!
Customer has a FoodMenu 但凡能够使用has a 来描述的，统一以属性的方式存在!
Cooker like a  FoodMenu  但凡能够使用like a 来描述的，是接口的实现者
*/ public class InterfaceFoodMenu { public static void main(String[] args) { //创建厨师对象 //FoodMenu cooker = new ChinaCooker(); //多态 //如果想换厨师 FoodMenu cooker = new AmericCooker(); //创建顾客对象 Customer customer = new Customer(cooker);//传什么样的厨师，最后调用的就是谁做的菜 //顾客点菜 customer.order();

    }
} //定义菜单接口----------围绕着接口编写 interface FoodMenu{ //接口里面都是抽象方法 //西红柿炒鸡蛋 void xiHongShiChaoJiDan(); //鱼香肉丝 void yuXiangRouSi();
} //顾客---有菜单接口（调用接口） class Customer{
    FoodMenu foodmenu; //顾客有菜单 //构造方法 public Customer() {
    } public Customer(FoodMenu foodmenu) { this.foodmenu = foodmenu;
    } //setter and getter public FoodMenu getFoodmenu() { return foodmenu;
    } public void setFoodmenu(FoodMenu foodmenu) { this.foodmenu = foodmenu;
    } //调用菜单的方法 public void order(){ //使用getFoodmenu()方法获取菜单 FoodMenu fm = this.getFoodmenu();
        fm.xiHongShiChaoJiDan();
        fm.yuXiangRouSi(); //在本类中，也可可以直接使用foodmenu调菜单 //foodmenu.xiHongShiChaoJiDan(); //foodmenu.yuXiangRouSi(); }
} //厨师---实现接口 //中餐厨师-------继承过来的抽象方法要重写 class ChinaCooker implements FoodMenu{ public void xiHongShiChaoJiDan(){
        System.out.println("中餐师傅做的西红柿炒鸡蛋");
    } public void yuXiangRouSi(){
        System.out.println("中餐师傅做的鱼香肉丝");
    }

} //西餐厨师-------继承过来的抽象方法要重写 class AmericCooker implements FoodMenu{ public void xiHongShiChaoJiDan(){
        System.out.println("西餐师傅做的西红柿炒鸡蛋");
    } public void yuXiangRouSi(){
        System.out.println("西餐师傅做的鱼香肉丝");
    }
}