Java入门之面向对象

1、Java的核心思想是OOP（Object-Oriented Programming)

　　本质上就是，以类的方式组织代码，以对象的组织封装数据。

　　从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。

　　从代码运行角度考虑是先有类后有对象。类是对象的模板。

2、三大特性

• 封装：高内聚，低耦合；属性私有，通过get()/set()方法来获取和赋值
• 继承：通过extends关键字来表示子类继承父类，只能是单继承。
• 多态：同一方法可以根据发送对象的不同类型而采用多种不同的行为方式；一个对象的实际类型是确定的，但可以指向对象的引用类型有很多。

public class Pet {
    public void run(){
        System.out.println("Pet run");
    }
}

public class Dog extends Pet{
    private String name; //属性私有
    //Alt+Insert来生成get/set方法  供外面的类进行访问
    public String getName() {
        return name;
    }

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

    @Override
    public void run() {
        System.out.println("Dog run");
    }

    public void eat(){
        System.out.println("Dog eat");
    }
}

public class Application {

    public static void main(String[] args) {
        Dog dog1 = new Dog();
        dog1.setName("kk");
        System.out.println(dog1.getName());
        //父类引用指向子类对象
        Pet dog2 = new Dog();
        Object dog3 = new Dog();
        dog1.run(); // 执行子类的run();
        dog2.run();//执行父类的run();  但是因为子类重写了父类的run(); 所以还是执行了子类的run();
        dog1.eat();
//        dog2.eat(); //父类不能调用子类特有的方法，除非进行类型转换
        ((Dog) dog2).eat();
    }
}

 

3、类与对象的关系

• 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是不能代表某一个具体的事物。
• 对象是抽象概念的具体实例

4、创建与初始化对象

• 使用new关键字创建对象
• 使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有2个特点：（1）必须和类名相同；（2）必须没有返回类型，也不能写void

public class Student {
    //一个类即使什么都不写，它也会存在一个方法
    int id;
    String name;

    //无参构造

    public Student() {
        System.out.println("1");
    }
    //有参构造
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
        System.out.println("2");
    }
}

public class Application {

    public static void main(String[] args) {
        //使用new关键字，本质是在调用构造器
        Student student = new Student(); 
        System.out.println("=========================");
        Student a = new Student(1, "a");

    }
}

 一旦定义有参构造，无参构造必须显示定义，否则无参构造会失效

5、super和this关键字

• super调用父类的构造方法，必须在构造方法的第一个；
• super必须只能出现在子类的方法或构造方法中；
• super和this不能同时调用构造方法（this也是只能在构造方法中的第一个);

　　this:本身调用者的对象，没有继承也能使用。this();本类的构造

　　super：代表父类对象的应用，只能在继承条件下使用。super();父类的构造

public class Person {
    protected String name = "kk";

    public Person() {
        System.out.println("Person Constructor!");
    }

    public void print(){
        System.out.println("Person");
    }
}

public class Student extends Person{
    private String name = "cc";

    public Student() {
        //隐藏代码，调用父类的无参构造
        //super();
        System.out.println("Student Constructor!");
    }

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();
        this.print();
        super.print();
    }
}

public class Application {

    public static void main(String[] args) {
        Student student = new Student();
        System.out.println("====================");
        student.test("qq");
        System.out.println("=====================");
        student.test1();
    }
}

6、方法的重写

　　需要有继承关系，子类重写父类的方法。

• 方法名必须相同；
• 参数列表必须相同；
• 修饰符范围可以扩大但不能缩小；
• 抛出的异常范围可以被缩小但不能扩大；

7、多态存在的条件

• 有继承关系
• 子类重写父类方法,static和final,private修饰的方法不能被重写。
• 父类引用指向子类

多态是方法的多态，属性没有多态性。

对象能执行哪些方法，主要看对象左边的类型，和右边关系不大。

Person p     =       new Student();

[引用类型]           [实际对象]

8、instanceof 类型转换

　　instanceof 是二目运算符，用来测试一个对象是否为一个类的实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。

　　类型转换：

• 父类引用执向子类对象
• 把子类转换为父类，向上转型；
• 把父类转换为子类，向下转型，需要强制转换；

    public static void main(String[] args) {
        Pet pet = new Dog();
        System.out.println(pet instanceof Dog); //true
        System.out.println(pet instanceof Pet); //true
        System.out.println(pet instanceof Object); //true
//        System.out.println(obj instanceof String); // 编译报错
    }

public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        Pet pet = dog;
        ((Dog)pet).eat();
    }

9、抽象类

　　用abstract关键字来修饰的类，抽象类；用abstract来修饰方法，抽象方法。抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类。抽象类中可以写普通方法。

　　抽象类不能使用new关键字来创建对象，它是用来让子类继承的。

　　抽象方法只有方法的声明，没有方法的实现，它是用来让子类实现的。

　　子类继承抽象类，那么必须实现抽象类没有实现的抽象的方法，否则该子类也要声明为抽象类。

public abstract class A {
    public void add(){
        
    }
    //抽象方法
    public abstract void modify();
}

public class B extends A{
    @Override
    public void modify() {

    }
}

 

10、接口

• 普通类：只有具体实现
• 抽象类：具体实现和规范（抽象方法）都有
• 接口：只有规范，方法都是public abstract,属性都是public static final修饰

　　接口都需要实现类，接口用interface来定义，实现类中使用implements来实现多个接口。接口中没有构造方法，不能被实例化。

public interface A {
    
    void modify();
    
    void select();
    
}

public interface C {
    void delete();
    String getName();
}

//可实现多个接口，但必须重写所有的方法
public class B implements A,C{

    @Override
    public void modify() {

    }

    @Override
    public void select() {

    }

    @Override
    public void delete() {

    }

    @Override
    public String getName() {
        return null;
    }
}

 

11、内部类

　　在一个类的内部再定义一个类。一个Java类中只能有一个public class，但可以有多个class。

• 成员内部类：通过外部类来实例化内部类，可以获得外部类的私有属性。
• 静态内部类
• 局部内部类
• 匿名内部类

public class Outer {
    private int id = 10;

    public void out(){
        System.out.println("outer method");
    }
    //成员内部类
    class Inner{
        public void in(){
            System.out.println("inner method");
        }
        public void getOutId(){
            System.out.println(id);
        }
    }

}

public class Application {

    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner(); //通过外部类来实例化内部类
        inner.in();
        inner.getOutId();
    }
}

public class Outer {
    private int id = 10;

    public void out(){
        System.out.println("outer method");
    }
    //静态内部类
    public static class Inner{
        public void in(){
            System.out.println("static inner method");
        }
//        public void getOutId(){
//            System.out.println(id); //无法访问非静态属性
//        }
    }

public class Outer {
    public void method(){
        //局部内部类
        class inner{
            public void in(){}
        }
    }
}

public class Application {

    public static void main(String[] args) {
        //匿名内部类
        new Ap().test(); //匿名对象使用，不用将实例保存到变量中
        new Service(){

            @Override
            public void add() {
                
            }
        };
    }
}
class Ap{
    public void test(){
        System.out.println("a");
    }
}
interface Service{
    void add();
}