Java-面向对象编程

面向对象编程

什么是面向对象

一个类调用另一个类中的方法:

//学生类
public class Student {
    //静态方法,通过"类名.方法名"调用
    public static void say(){
        System.out.println("学生说话了");
    }
    //非静态方法,通过"对象名.方法名"调用
    public void say01(){
        System.out.println("01说话了");
    }
}

public class Demo02 {
    public static void main(String[] args) {
        //静态方法调用
        Student.say();
        //非静态方法调用
        Student student = new Student();
        student.say01();
    }
    //和类一起加载的
    public static void a(){
        //b();//会报错
    }
    //类实例化之后才加载的
    public void b(){

    }
}

值传递:

//Java是值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);//1
        Demo04.change(a);
        System.out.println(a);//1
    }
    //返回值为空
    public static void change(int a){
        a = 10;
    }
}

引用传递:

//引用传递:对象,本质还是值传递
//对象-内存
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null
        Demo05.change(person);
        System.out.println(person.name);//超人
    }
    public static void change(Person people){
        //people是一个对象:指向->Person person = new Person();
        //这是一个具体的人,可以改变属性
        people.name = "超人";
    }
}
//定义一个Person类,有一个属性:name
class Person{
    String name;//默认为null
}

创建与初始化对象

new

package com.oop.demo02;
//学生类
public class Student {
    //属性:字段
    String name;//null
    int age;//0

    //方法
    public void study(){
        System.out.println(this.name + "在学习");
    }
}

package com.oop.demo02;
//应用类,一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类:抽象,实例化
        //类实例化后会返回一个自己的对象
        //mike对象就是一个Student类的具体实例
        Student mike = new Student();
        mike.name = "麦克";
        mike.age = 20;
        System.out.println(mike.name + mike.age);//麦克20
    }
}

构造器

package com.oop.demo02;
//java文件 编译后-> class文件
public class Person {
    //一个类即使什么都不写,它也会存在一个方法
    //显示定义构造器
    String name;
    int age;

    //alt + insert 快速定义构造器

    //1.使用new关键字,本质是在调用构造器
    //2.用来初始化值
    public Person() {
    }
    //有参构造:一旦定义了有参构造,无参就必须显示定义,否则不能实例化没有参数的对象
    public Person(String name) {
        this.name = name;
    }
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
}
/*
    构造器:
    1.和类名相同
    2.没有返回值
    作用:
    1.new本质在调用构造方法
    2.初始化对象的值
    注意点:
    1.定义有参构造之后,如果想使用无参构造,显示的定义一个无参的构造
    Alt + Insert
    this. =
*/

package com.oop.demo02;
//应用类,一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //new 实例化一个对象
        Person person = new Person("chaoren",20);
        System.out.println(person.name);
    }
}

总结:

1. 类与对象

   类是一个模板:抽象,对象是一个具体的实例

2. 方法

   定义、调用！

3. 对应的引用

   引用类型:除基本类型(8种)外都是引用类型

   ​ 对象是通过引用来操作的:栈—>堆

4. 属性:字段Field 成员变量

   默认初始化:

   ​ 数字:0,0.0

   ​ char:u0000

   ​ boolean:false

   ​ 引用:null

   修饰符 属性类型 属性名 = 属性值！

5. 对象的创建和使用

   • 必须使用new 关键字创建对象,构造器
     Person chaoRen = new Person();
   • 对象的属性 chaoRen.name
   • 对象的方法 chaoRen.sleep()

6. 类:

   静态的属性 属性

   动态的行为 方法

7. 封装、继承、多态

封装

package com.oop.demo04;
//类     private:私有
public class Student {
    //属性私有
    private String name;//名字
    private int id;//学号
    private char gender;//性别
    private int age;

    //提供一些可以操作这个属性的方法
    //提供一些public的get、set方法

    //get获得这个数据
    public String getName(){
        return this.name;
    }
    //set给这个数据设置值
    public void setName(String name){
        this.name = name;
    }

    //alt + insert

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120 || age<0){//不合法
            this.age = 3;
        }else{
            this.age = age;
        }
    }
}

package com.oop.demo04;
/*
    1.提高程序的安全性,保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统可维护增加了
 */
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("超人");
        System.out.println(s1.getName());
        s1.setAge(999);
        System.out.println(s1.getAge());//3
    }
}

继承

object类

在Java中,所有的类,都默认直接或者间接继承Object

super-this

package com.oop.demo05;
//人：父类
public class Person {

    public Person() {
        System.out.println("Person无参执行");
    }

    //保护:可用super调用
    protected String name = "父类名字";

    //private:私有的无法被继承,super也调用不了
    public void print(){
        System.out.println("Person");
    }
}

package com.oop.demo05;
//子类继承父类,就会有父类的全部方法
//学生 is 人 ：派生类，子类
public class Student extends Person {

    public Student() {
        //无参构造器中的隐藏代码:"super();"调用了父类的无参构造
        super();//调用了父类的构造器,必须在子类构造器的第一行
        //this("nihao");//this的有参构造也要放在第一行,所以和上面的super只能二选一,不能一起用
        System.out.println("Student无参执行");
    }

    //有参构造
    public Student(String name) {
        this.name = name;
    }

    private String name = "子类本名";

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

    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }

    public void test(String name){
        System.out.println(name);//超人
        System.out.println(this.name);//子类本名
        System.out.println(super.name);//父类名字
    }
}

package com.oop.demo05;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.test("超人");
        s1.test1();
    }
}
/*
super注意点:
    1.super调用父类的构造方法，必须在构造方法的第一个
    2.supper必须只能出现在子类的方法或者构造方法中
    3.super和this不能同时调用构造方法
Vs this:
    代表的对象不同:
        this:   本身调用者这个对象
        super:  代表父类对象的引用
    前提:
        this:   没有继承也可以使用
        supper: 只能在继承条件下才可以使用
    构造方法:
        this():     本类的构造
        supper():   父类的构造！
*/

重写

重写都是方法的重写,和属性无关

package com.oop.demo05;

public class B {
    //静态
    /*public static void test(){
        System.out.println("B->test()");
    }*/
	//非静态
    public void test(){
        System.out.println("b->test()");
    }
}

package com.oop.demo05;

public class A extends B {
    /*public static void test(){
        System.out.println("A->test()");
    }*/

    //Override 重写
    @Override//注解:有功能的注释
    public void test() {
        //super.test();
        System.out.println("A->test()");
    }
}

package com.oop.demo05;

public class Application {
    public static void main(String[] args) {
        A a = new A();

        //父类的引用指向了子类
        B b = new A();

        //当A类和B类使用有static时的静态方法
        //a.test();//A->test()
        //b.test();//B->test()

        //当A类和B类使用没有static时的非静态方法
        a.test();//A->test()
        b.test();//A->test()

        /*
            1.没有static时，b调用的是对象的方法，
            而b是用A类new的对象，因此调用了A的方法。
            这种是重写了父类的方法，重写只和非静态有关。
            2.有static时，b调用B类的方法，因为b是用B类定义的，
            且静态方法是类的方法，而非静态方法是对象的方法。

            重写：需要有继承关系，子类重写父类的方法！
                1.方法名必须相同
                2.参数列表必须相同
                3.修饰符：范围可以扩大：
                    public>protected>default>private
                4.抛出的异常：范围，可以缩小但不能扩大
                    ClassNotFoundException->Exception(大)

            重写，子类的方法名和父类必须要一致，方法体不同！

            为什么需要重写：
                1.父类的功能，子类不一定需要或者不一定满足！
                    Alt + Insert: Override
         */
    }
}

多态

什么是多态

package com.oop.demo06;

public class Person {

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

package com.oop.demo06;

public class Student extends Person {
    @Override
    public void run() {
        //super.run();
        System.out.println("子");
    }

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

package com.oop.demo06;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的（new-实例）
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了:父类的引用指向子类

        //Student能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //子类没有重写父类时
        //s2.run();//父
        //s1.run();//父

        //子类重写父类方法时
        s2.run();//子
        s1.run();//子

        //此Person类应用 并没有 指向子类的实例，所以调用的是父类自己的方法
        Person p1 = new Person();
        p1.run();//父

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        //Person s3 = new Student();
        //Person类中并没有"eat()方法"
        //s3.eat();//报错
        s1.eat();//eat
        //把Person类型强制转换成Student类型，就能调用子类方法
        ((Student) s2).eat();//eat
    }
}

/*
多态注意事项：
    1.多态是方法的多态，属性没有多态
    2.父类和子类，有联系 类型转换异常！ ClassCastException!
    3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！
        Father f1 = new Son();
不能重写的：
    1.static方法：属于类，不属于实例
    2.final常量
    3.private方法：私有的
 */

instanceof

用于判断两个对象之间是否有父子关系

package com.oop.demo06;
public class Person {
}

package com.oop.demo06;
public class Student extends Person {   
}

package com.oop.demo06;
public class Teacher extends Person {
}

package com.oop.demo06;
public class Application {
    public static void main(String[] args) { 
        //继承关系有下列三种：    
        //Object->String
        //Object->Person->Teacher
        //Object->Person->Student
        Object object01 = new Student();

        //System.out.println(x instanceof y);
        //编译能不能通过主要看x和y之间是否有（继承）关系
        //编译通过后，得出的结果有true和false
        //true:y和x有继承关系
        //false:y和x没有继承关系
		
        /*1.编译判断：
        	可以理解为左边的引用类型和右边用来比较的类型为一条线,
            如果这条线没有父子关系,编译就不通过
            比如下方的"object01"的引用类型为"Object",
            用来比较的类型为"object01 instanceof Student"中的"Student"
            且它们两个都在Object->Person->Student，可看出有父子关系,所以编译通过
          2.true和false判断：
          	编译通过后,"object01"是"new Student"实例化的对象,所以对象是Student类型
            和"object01 instanceof Student"中的"Student"
            都是在Object->Person->Student的继承关系中，所以结果为true
          总结：编译能否通过看左边的引用类型，true和false看右边new实例化出来的对象类型
        */
        
        System.out.println(object01 instanceof Student);//true
        System.out.println(object01 instanceof Person);//true
        System.out.println(object01 instanceof Object);//true
        System.out.println(object01 instanceof Teacher);//false
        System.out.println(object01 instanceof String);//false

        System.out.println("==========");

        Person person01 = new Student();
        System.out.println(person01 instanceof Student);//true
        System.out.println(person01 instanceof Person);//true
        System.out.println(person01 instanceof Object);//true
        System.out.println(person01 instanceof Teacher);//false
        //System.out.println(person01 instanceof String);//编译就报错

        System.out.println("==========");

        Student student01 = new Student();
        System.out.println(student01 instanceof Student);//true
        System.out.println(student01 instanceof Person);//true
        System.out.println(student01 instanceof Object);//true
        //System.out.println(student01 instanceof Teacher);//编译就报错
        //System.out.println(student01 instanceof String);//编译就报错
    }
}

类型转换

package com.oop.demo06;
public class Person {
}

package com.oop.demo06;
public class Student extends Person {
    public void go(){
        System.out.println("go");
    }
}

package com.oop.demo06;
public class Application {
    public static void main(String[] args) {        
        //类型之间的转换：父(高)     子(低)
        //低->高不用强制转换；高->低需要强制转换

        //高                   低
        Person obj = new Student();
        //obj.go();//报错
        //将obj对象转换成Student类型,我们就可以使用Student类型的方法
        Student student02 = (Student) obj;
        student02.go();//go
        //简写
        ((Student) obj).go();//go

        Student student03 = new Student();
        student03.go();//go
        Person person02 = student03;//低->高
        //person02.go();//报错
        //所以子类转换为父类,可能丢失自己本来的一些方法!
    }
}

/*
    1.只有父类引用指向子类对象(子类引用是不能指向父类对象的)
    2.把子类转换为父类,向上转型
    3.把父类转换为子类,向下转型：强制转换
    4.转换是为了方便方法的调用,减少重复的代码！

    抽象：封装、继承、多态!
 */

static关键字详解

package com.oop.demo07;
//static:静态-都是class类一加载就加载出来的
public class Student {
    private static int age;//静态的变量  多线程使用的多
    private double score;//非静态的变量

    public void run(){go();}

    public static void go(){}

    public static void main(String[] arg){
        Student s1 = new Student();

        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println(s1.score);

        new Student().run();
        Student.go();
        go();
    }
}

package com.oop.demo07;

public class Person {
    {
        //代码块（匿名代码块）
        //用于赋初始值
        System.out.println("匿名代码块");
    }

    static{
        //静态代码块
        //类一加载就执行,且只执行一次
        System.out.println("静态代码块");
    }

    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person01 = new Person();
        /*
        输出：
            1.静态代码块
            2.匿名代码块
            3.构造方法
         */
        System.out.println("==========");
        Person person02 = new Person();
        /*
        输出：
            1.匿名代码块
            2.构造方法
         */
    }
}

package com.oop.demo07;
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
    public static void main(String[] args) {
        //Math.random() 随机返回一个随机数
        System.out.println(Math.random());
        //如果想简写为random(),需要 静态导入包
        System.out.println(random());
        System.out.println(PI);
    }
}

//通过final修饰的类不能被继承,即没有子类
public final class Person {
}

抽象类

package com.oop.demo08;
//abstract 抽象类
//类 extends:单继承     但是接口可以多继承
public abstract class Action {
    //约束~有人帮我们实现~
    //abstract,抽象方法,只有方法名,没有方法的实现！
    public abstract void doSomeThing();
}
/*
特点：
    1.不能new这个抽象类,只能靠子类去实现它:约束！
    2.抽象类中可以写普通方法
    3.抽象方法必须在抽象类中
    抽象的抽象：约束

    子类继承父类后,需要通过父类的构造器来实例化,所以抽象类也需要构造器
    抽象类存在的意义：把公有的抽象出来,为了使代码更简约
 */

package com.oop.demo08;
//抽象类的所有方法,继承了它的子类,都必须实现它的方法,除非子类也是抽象类
public class A extends Action{
    @Override
    public void doSomeThing() {
    }
}

接口

package com.oop.demo09;

//重要是锻炼抽象的思维,这个很难,少数厉害的人才能因此做到架构师

//interface 定义的关键字,接口都需要有实现类
public interface UserService {
    //接口中定于的属性都是静态常量 public static final
    int AGE = 99;

    //接口中所有定义的方法其实都是抽象的，默认都是:public abstract
    void add(String name);//添加名字
    void delete(String name);//删
    void update(String name);//改
    void query(String name);//查
}
/*
作用：
    1.约束
    2.定义一些方法,让不同的人实现
    3.方法->public abstract
    4.常量->public static final
    5.接口不能被实例化,因为接口中没有构造方法
    6.implements可以实现多个接口
    7.必须要重写接口中的所有方法
 */

package com.oop.demo09;

public interface TimeService {
    void timer();
}

package com.oop.demo09;
//类 可以实现接口 implements 接口
//实现了接口的类,就需要重写接口中的所有方法
//利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void add(String name) { }

    @Override
    public void delete(String name) { }

    @Override
    public void update(String name) { }

    @Override
    public void query(String name) { }

    @Override
    public void timer() { }
}

内部类

package com.oop.demo10;
//外部类
public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("外部类的方法");
    }
    //内部类
    class Inner{
        public void in(){
            System.out.println("内部类的方法");
        }

        //获得外部类的私有属性
        //但是如果内部类添加static修饰就没办法访问
        //因为静态的类比普通属性更先运行,除非在id属性前也添加static修饰
        public void getID(){
            System.out.println(id);
        }
    }

    public void method(){
        //局部内部类
        class B{
            public void in(){}
        }
    }
}
//也是内部类
//一个java类中可以有多个class类,但只能有一个public class
class A{
    public static void main(String[] args) {

    }
}

package com.oop.demo10;
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();//内部类的方法
        inner.getID();//10
    }
}

匿名内部类(安卓必备)

package com.oop.demo10;
public class Test {
    public static void main(String[] args) {
        //没有名字初始化类,不用实例保存到变量中
        new Apple().eat();

        //匿名类-学习安卓必备技能
        //下面的匿名类返回的是"UserService userService"这个对象
        new UserService(){
            @Override
            public void hello() {

            }
        };
    }
}
//内部类
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
//接口
interface UserService{
    void hello();
}