Java面向对象思想

Posted 2020-11-04 joy410-love

Java类的定义：

 

成员变量会默认初始化，局部变量不会默认初始化。

 如何在内存中区分类和对象：

      ?类是静态的概念，代码区

      ?对象是new出来的，位于堆内存，类的每一个成员变量在不同的对象中都有不同的值（除了静态变量）而方法只有一份，执行的时候才占用内存。

对象的创建和使用：

  ?必须使用new关键字创建对象

  ?使用对象（引用).成员变量或来引用对象的成员变量    

　　Dog d = new Dog();
　　d.getFurColor();

  ?使用对象（引用).方法（参数列表）来调用对象的方法   

　　Dog d = new Dog();
　　Mouse mm = new Mouse();
　　d.catchMouse(mm);

  ?同一类的每个对象有不同的成员变量存储空间

  ?同一类的每个对象共享该类的方法

Dog类：

public class Dog {
    
    String furColor;
    float height;
    float weight;

    void catchMouse(Mouse m) {
        m.scream(m);
    }
    public static void main(String[] args) {
        Dog d = new Dog();
        Mouse mm = new Mouse();
        d.getFurColor();
        d.catchMouse(mm);

    }    
}

 

Persion类：

public class Persion {
    
    public static void main(String[] args) {
        Persion p = new Persion();
        Persion p1 = new Persion(400);
        p.info();
        p.info("ok");
    }

    //成员变量
    private int id;
    private int age = 20;
    //方法定义
    public int getAge(){return age;}
    public void setAge(int i){age = i;}
    public int getId(){return id;}
    
    void info() {
        System.out.println("my id is :" + id);
    }
    
    void info(String t){
        System.out.println(t + "id" + id);
    }
    
    Persion(){
        id = 100;
        age = 20;
    }
    
    Persion(int _id){
        id = _id;
        age = 30;
    }
    
    Persion(int _id,int _age){
        id = _id;
        age = _age;
    }
}

 

 构造方法重载：

  ?与普通方法一样，构造方法也可以重载

 

 Persion(){
        id = 100;
        age = 20;
    }
    
    Persion(int _id){
        id = _id;
        age = 30;
    }
    
    Persion(int _id,int _age){
        id = _id;
        age = _age;
    }

this关键字：

 ?在类的方法定义中使用的this关键字代表使用该方法的对象的引用

 ?当必须指出当前使用方法的对象是谁时要使用this

 ?使用this可以处理方法中成员变量和参数重名的情况

 ?this可以看作一个变量，它的值是当前对象的引用

 super关键字：

 ?在类中，用static声明的成员变量为静态变量，它为该类的公用变量，在第一次使用时被初始化，对于该类的所有对象来说，static成员变量只有一份

 ?用static声明的方法为静态方法，在调用改方法时，不会讲对象的引用传递给他，所以在static方法中不可访问非static的成员

      静态方法不再是针对于某个对象调用，所以不能访问非静态成员

 ?可以通过对象的引用或类名（不需要实例化）访问静态变量。

 

public class Cat {
    
    private static int sid = 0;
    private String name;
    int id;
    
    Cat(String name){
        this.name = name;
        id = sid++;
    }
    public void info(){
        System.out.println("My name is"+name+"No."+id);
    }

    public static void main(String[] args) {
        Cat.sid = 100;
        Cat mimi = new Cat("mimi");
        Cat pipi = new Cat("pipi");
        mimi.info();
        pipi.info();
    }
}

 

继承：

public class Persion {
    private String name;
    private int age;
    
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

class Student extends Persion{
    private String school;

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }    
}

class Test{
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("John");
        student.setSchool("SCH");
        student.setAge(24);
        System.out.println(student.getName());
        System.out.println(student.getAge());
        System.out.println(student.getSchool());
    }
}

 

方法重写：

 ?在子类中可以根据需要对从基类中继承来的方法进行重写

 ?重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型

 ?重写方法不能使用比被重写方法更严格的访问权限

class Person {
    private String name;
    private int age;
    public void setName(String name){this.name=name;}
    public void setAge(int age) {this.age=age;}
    public String getName(){return name;}
    public int getAge(){return age;}
    public String getInfo() {
          return "Name: "+ name + "\\n" +"age: "+ age;
  }
}

class Student extends Person {
    private String school;
    public String getSchool() {return school;}
    public void setSchool(String school)
    {this.school =school;}
    public String getInfo() {
      return  "Name: "+ getName() + "\\nage: "+ getAge() 
                    + "\\nschool: "+ school;    //重写
        }
}

public class TestOverWrite {
public static void main(String arg[]){
        Student student = new Student();
        Person person = new Person();
        person.setName("none");
        person.setAge(1000);
        student.setName("John");    
        student.setAge(18);
        student.setSchool("SCH");
        System.out.println(person.getInfo());
        System.out.println(student.getInfo());
    }
}

 

super关键字：

  ?在java类中使用super来引用基类的成分：

public class TestInherit {
    
    public static void main(String[] args) {
        ChildClass cc = new ChildClass();
        cc.f();
    }
    
}

class ChildClass extends FatherClass{
    public int value;
    public void f(){
        super.f();
        value = 200;
        System.out.println("ChildClass.value="+value);
        System.out.println(value);
        System.out.println(super.value);
    }
}

class FatherClass{
    public int value;
    public void f(){
        value = 100;
        System.out.println("FatherClass.value="+value);
    }
}

打印结果为：
FatherClass.value=100
ChildClass.value=200
200
100

 继承中的构造方法：

    ?子类的构造的过程中必须调用其父类的构造方法

   注释super（300）；会报错。原因如上  

SubClass() {
		super(300);
		System.out.println("SubClass()");
	}

    ?子类可以在自己的构造方法中使用super（argument_list）调用父类的构造方法。

        ?使用this（argument_list）调用本类的另外的构造方法。

        ?如果使用super，必须写在子类构造方法的第一行。

         调换super（300）位置；会报错。原因如上  

SubClass() {
		super(300);
		System.out.println("SubClass()");
	}　

    ?如果子类的构造方法中没有显示地调用父类构造方法，则系统默认调用父类的无参构造方法。

public class TestSuperSub {

    public static void main(String[] args) {
        //SubClass sc1 = new SubClass();
        SubClass sc2 = new SubClass();
    }

}

打印结果：
SuperClass(300)
SubClass() 

    ?如果子类构造方法中既没有显示调用父类构造方法，而父类中有没有无参构造方法，则编译出错。

注释这个父类的构造方法，编译出错，原因如上。

    SuperClass() {
        System.out.println("SuperClass()");
    }

整体练习代码：

package com.luluyu.test;

public class TestSuperSub {

    public static void main(String[] args) {
        SubClass sc1 = new SubClass();
        SubClass sc2 = new SubClass();
    }

}

class SuperClass {
    private int n;

    SuperClass() {
        System.out.println("SuperClass()");
    }

    SuperClass(int n) {
        System.out.println("SuperClass(" + n + ")");
        this.n = n;
    }
}

class SubClass extends SuperClass {
    private int n;

    SubClass(int n) {
        // super();
        System.out.println("SubClass(" + n + ")");
        this.n = n;
    }

    SubClass() {
        super(300);
        System.out.println("SubClass()");
    }

}

对象转型：

?一个父类的引用类型变量可以“指向”其子类的对象。

?一个父类的引用不可以访问其子类对象新增加的成员（属性和成员）。

?可以使用引用变量instanceof类名来判断该引用型变量所“指向”的对象是否属于该类或该类的子类。

?子类的对象可以当作父类的对象来使用称作向上转型，反之称为向下转型。

 

练习代码：

package com.luluyu.test;

public class test {

public static void main(String[] args) {
Animal a = new Animal("name");
Cat c = new Cat("catname","blue");
Dog d = new Dog("dogname","black");

System.out.println(a instanceof Animal);//true
System.out.println(c instanceof Animal);//true
System.out.println(d instanceof Animal);//true
System.out.println(a instanceof Cat);//false

a = new Dog("bigyellow","yellow");
System.out.println(a.name);//bigyellow
System.out.println(a instanceof Animal);//true
System.out.println(a instanceof Dog);//true

Dog d1 = (Dog) a;//强制类型转化
System.out.println(d1.eyesColor);//yellow
}

}

class Animal{

public String name;

public Animal(String name) {
this.name = name;
}

}

class Cat extends Animal{

public String eyesColor;

Cat(String n,String c) {
super(n);
eyesColor=c;
}
}

class Dog extends Animal{

public String eyesColor;

Dog(String n,String c) {
super(n);
eyesColor=c;
}

多态绑定和多态：

动态绑定是指在执行期间（而非编译期间）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

多态需要三个条件：

    1.要有继承

    2.要有重写

    3.父类引用指向子类对象

 

package com.luluyu.op;

public class Test {

    public static void main(String[] args) {
        Cat c = new Cat("catname", "blue");
        Dog d = new Dog("Dogname", "black");
        Lady L1 = new Lady("L1", c);
        Lady L2 = new Lady("L2", d);

        L1.myPetEnjoy();
        L2.myPetEnjoy();

    }

}

class Animal {
    private String name;

    public Animal(String name) {
        super();
        this.name = name;
    }

    public void enjoy() {
        System.out.println("叫声。。。。。。。。");
    }
}

class Cat extends Animal {

    private String eyesColor;

    public Cat(String n, String c) {
        super(n);
        eyesColor = c;
    }

    public void enjoy() {
        System.out.println("猫叫声。。。。。。。");
    }

}

class Dog extends Animal {

    private String furColor;

    public Dog(String n, String c) {
        super(n);
        furColor = c;
    }

    public void enjoy() {
        System.out.println("狗叫声。。。。。。。");
    }

}

class Lady {

    private String name;
    private Animal pet;

    public Lady(String name, Animal pet) {
        this.name = name;
        this.pet = pet;
    }

    public void myPetEnjoy() {
        pet.enjoy();
    }

}

 

 

 

 

抽象类：

   ?用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，该方法叫做抽象方法。

   ?含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写

   ?抽象类不能被实例化

   ?抽象方法只需声明，而不被实现

/**
 * 
 * 当一个类有抽象方法时，这个类必须是抽象类
 *
 */
abstract class Animal {
    private String name;

    public Animal(String name) {
        super();
        this.name = name;
    }

    public abstract void enjoy();
}

 

 

 

 

abstract class Animal {
    private String name;

    public Animal(String name) {
        super();
        this.name = name;
    }
    public abstract void enjoy();
}


/***
 *含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写
 */
abstract class Cat extends Animal {

    private String eyesColor;

    public Cat(String n, String c) {
        super(n);
        eyesColor = c;
    }

    public abstract void enjoy();

}

 

 

 

final关键字：

   ?final修饰变量的值不能够被改变

        ?final修饰的成员变量

        ?final修饰的局部变量（形参）

   ?final修饰的方法不能够被重写

   ?final修饰的类不能够被继承

接口：

   ?接口是抽象方法和常量值的定义的集合

   ?从本质上讲，接口是一种特殊的抽象类，这种抽象类只包含常量和方法的定义，而没有变量和方法的实现

 

public interface Runner {

    public void start();
    public void run();
    public void stop();
}

 

 

 

接口的特性：

   ?接口可以多重实现

   ?接口中声明的属性默认为public static final的，也只能是public static final

   ?接口中只能定义抽象方法，而且这些方法默认为public，也只能是public

   ?接口可以继承其它的的接口，并添加新的属性和抽象方法