Java Se 基础系列(笔记) -- OO

记录所学到的关于Java Se的一些基础知识

1.对象是通过“属性(成员变量)”和“方法”来分别对应事物所具有的静态属性和动态属性

2.类(Class)是对某一类事物的抽象，对象(Object)为某个类的具体实例(Instance)

3.面向对象的思维：考虑问题里头有哪些类哪些对象，考虑它们应该具有哪些属性和方法，再考虑类和类之间具备了什么关系

4.成员变量和局部变量的区别：

　　-1 位于类体中方法体外的为成员变量，方法体内的为局部变量

　　-2 在定义成员变量时可对其进行初始化，如果不初始化，java会使用默认的值(0/null)对其初始化；局部变量不会被默认初始化所以必须自己去初始化

5.引用类型占两块内存(new出来的东西在heap中，局部变量位于stack，静态变量和字符串常量在dataseg区)

Person p = new Person("圣诞");
 
class Person {
    String name = null;
 
    public Person(String name) {
        this.name = name;
    }
}

　　

6.同一类中的每个对象有不同的成员变量存储空间，同一类的每个对象共享该类的方法

7.类名首字母大写，变量名和方法名首字母小写

8.this是指向自身的引用

9.在类中，用static声明的成员变量为静态成员变量，为该类的公用变量，对该类的所有对象来说static成员变量只有一份；用static声明的方法为静态方法，不再针对于某个对象调用而且在静态方法中不能访问非静态变量。(静态变量和静态方法可以不用创建对象就调用(也可通过类名进行调用)，非静态变量和方法必须创建对象后才能被调用)

10.java 权限修饰符(对class(除了内部类)的权限只能用public和default。-1.public类可以在任意地方被访问   -2.default类只可以被同一个包内部的类访问)

	类内部	同一个包	子类	任何地方
private	√
default(没写修饰符)	√	√
protected	√	√	√
public	√	√	√	√

11.继承

　　-1 子类构造过程中必须调用父类(基类)的构造方法

　　-2 子类在自己的构造方法中使用super(argument_list)来调用父类的构造方法，并且必须写在子类构造方法的第一行；使用this(argument_list)来调用本类的另外的构造       　　　方法

　　-3 如果子类构造方法中没有显示调用基类的构造方法系统会默认调用基类的无参数构造方法；若既无显式调用而基类中又无无参数的构造方法则编译出错

 public class Test2 {
     public static void main(String[] args) {
         Person p1 = new Person("A");
         Person p2 = new Person("B", "shanghai");
         Student s1 = new Student("C", "S1");
         Student s2 = new Student("C", "shanghai", "S2");
 
         System.out.println(p1.info());
         System.out.println(p2.info());
         System.out.println(s1.info());
         System.out.println(s2.info());
     }
 }
 
 class Person {
     private String name;
     private String location;
 
     Person(String name) {
         this.name = name;
         location = "beijing";
     }
 
     //构造方法的重载
     Person(String name, String location) {
         this.name = name;
         this.location = location;
     }
 
     public String info() {
         return "name: " + name + " location: " + location;
     }
 }
 
 class Student extends Person {
     private String school;
 
     Student(String name, String school) {
         //this(argument_list)调用本类的另外的构造方法
         this(name, "beijing", school);
     }
 
     Student(String n, String l, String school) {
         //super(argument_list)调用父类的构造方法
         super(n, l);
         this.school = school;
     }
 
     public String info() {
         return super.info() + " school:" + school;
     }
 }

12.对象转型

　　-1 一个父类的引用类型变量可以"指向"其子类的对象

　　-2 一个父类的引用不可以访问其子类对象新增加的属性和方法

　　-3 可用： 对象名 instanceof 类名 来判断该对象是否属于该类或该类的子类

 public class TestCasting {
     public static void main(String[] args) {
         Animal a = new Animal("a");
         Cat c = new Cat("c", "blue");
         Dog d = new Dog("d", "yellow");
 
         //使用 变量instanceof类 来判断该变量是否属于该类或该类的子类
         System.out.println(a instanceof Animal);
         System.out.println(c instanceof Animal);
         System.out.println(d instanceof Animal);
         System.out.println(a instanceof Cat);
 
         //一个父类的引用可以指向其子类的对象
         a = new Dog("a_d", "brown");
         System.out.println(a instanceof Animal);
         System.out.println(a instanceof Dog);   //instanceof看的是它实际上是什么东西
         //System.out.println(a.furColor);  //error，一个父类的引用不能访问其子类对象新增加的属性和方法
         System.out.println(a.name);
         //将a从Animal类强转为Dog类
         Dog d1 = (Dog)a;
         System.out.println(d1.furColor);
     }
 }
 
 class Animal {
     public String name;
 
     public Animal(String name) {
         this.name = name;
     }
 }
 
 class Cat extends Animal {
     public String eyeColor;
 
     public Cat(String name, String eyeColor) {
         super(name);
         this.eyeColor = eyeColor;
     }
 }
 
 class Dog extends Animal {
     public String furColor;
 
     public Dog(String name, String furColor) {
         super(name);
         this.furColor = furColor;
     }
 }

13.多态(也叫动态绑定，在执行期间判断所引用对象的实际类型然后根据实际的类型调用其相应的方法)

　　多态存在的3个必要条件：1.继承   2.方法重写    3.父类引用指向子类对象

14.抽象类：

　　- 含有抽象方法的类必须声明为抽象类

　　- 抽象类必须被继承，抽象方法必须被重写，抽象类不能被实例化，抽象方法只需声明不需实现

15.final

　　 1.final的变量的值不能被改变    2.final方法不能被重写    3.final类不能被继承

16.接口(从本质上讲，接口是一个特殊的抽象类，该类中只包含常量和方法的定义，没有变量也没有方法的实现)

　　- 接口的特性

　　　　-1 接口中声明的属性默认为public static final(能且只能是public static final)，可省略不写　

　　　　-2 接口中只能定义抽象方法，这些方法同样能且只能是public

　　　　-3 接口可以继承其他接口并添加新的属性和抽象方法　　

　　　　-4 接口可以继承接口，类可以继承类，类实现接口　

　　- 与继承关系相似，接口与实现类之间存在多态性

 public class Test3 {
     public static void main(String[] args) {
         //接口的实现相当于继承；接口的实现必须有方法的重写；父类引用指向子类对象所以构成多态
         Person c = new Chinese();
         Person a = new American();
         //因此调用的是各自的speak方法
         c.speak();
         a.speak();
     }
 }
 
 interface Person {
     //默认为 public
     public void speak();
 }
 
 class Chinese implements Person {
     //实现了接口就必须重写接口中的所有方法
     public void speak() {
         System.out.println("中国人说中国话");
     }
 }
 
 class American implements Person {
     public void speak() {
         System.out.println("美国人说英文");
     }
 }