JavaSE 01 类和对象|继承多态

java基础

1、搭建环境  jdk、idea

2、语法基础
	数据类型：基本 4类 8种、引用
	类型转换：自动类型转换、强制类型转换   byte b1 = (byte)int;
	运算符： 
public class Demo1 {
    /*
    运算符：
        算术  ++  --   int i = 1; i = i+1; ====> i++
        逻辑  &&  &  ||  |
        三目  返回值 = 表达式1 ? 表达式2 : 表达式3  if...else
        比较
        赋值  += = 
     */
    public static void main(String[] args) {
        int i = 1;
        int j = ++i;//自身+1，然后使用=赋值运算符赋给左侧变量
        System.out.println(i);
        System.out.println(j++);
        System.out.println(j);
    }
}
3、选择结构
	if...else   if....elseif...elseif...else
	switch(byte|short|int|string|char|枚举){
		case 1:
			sout;
			break;
		default:
			
	}
4、循环结构
	for  明确循环次数
	
	while  
		break;
		continue; 
		
	do...while
		break;
	
5、循环嵌套和数组
	for(){
		for(){
		
		}
	}
	
	for(){
		while(){
		
		}
	}
	
	while(){
		do...while(){
		
		}
	}
	
6、数组  一维数组、二维数组
	二维数组：底层一维数组，一维数组的每一个元素又是一个一维数组。
	

7、方法（方法定义、方法调用）

	方法参数
	返回值
	调用
	
	public static void m1(int i){}  //形参  i
	
	main(){
		m1(1);//调用方法  1 实参
	}

类和对象

类是抽象的，对象是具体的。

创建类，通过类创建对象。

class Goods{
	//全局变量  有默认值   引用类型默认值为null
	//属性  对象属性（实例变量）
	double price;
	//方法
	public void toString(){
		int i ;//局部变量 使用之前必须初始化
	}
}

class Test{
	main{
		//创建Goods类对象
		//goods :变量名  对象名
		//int i ;
		Goods goods = new Goods();
		//调用对象的属性
		对象名.属性名 = 值;
		//对象名.方法名
		goods.toString();
	}
}

对象的内存分配（了解）

全局变量和局部变量

类名 变量名 = new 类名();

创建对象|创建实例

变量名|对象名|实例名

对象属性：随着对象而创建，在堆空间中存储

局部变量：随着方法的执行而创建，根据数据类型不同，基本数据类型在栈空间存储，引用数据类型值在堆空间存储。

package com.hl.pojo;
/*
设计一个代表圆的类。要求能计算圆的周长和面积。
 */
public class Circle {
    //属性 半径
    int r;
    //计算周长
    public double zc(){
        return 2 * Math.PI * r;
    }
    //计算面积
    public double area(){
        return Math.PI * r * r;
    }
}
class Goods{
    String name;
    double price;
    String color;
}
class User{
    String name;//姓名
    public void buy(Goods goods ){
        System.out.println(name+"---购买了"+goods.name+"--价格-"+goods.price+"--颜色"+goods.color);
    }
}

package com.hl.pojo;

public class Test {
    public static void main(String[] args) {
        //创建圆形类的对象
        //创建对象
        Circle c = new Circle();
        //给属性赋值
        c.r = 6;
        //调用方法
        System.out.println(c.zc());
        System.out.println(c.area());

        //创建一个商品对象
        Goods g = new Goods();
        g.name = "小米手机";
        g.price = 6999;
        g.color = "钻石黑";

        User user = new User();
        user.name = "阳光";
        //调用方法
        user.buy(g);
    }
}

面向对象的三大思想

封装: 属性私有化，提供公有的getter、setter方法对外提供数据

继承：Person <---- Student|Teacher

多态：父类的引用指向子类对象或者接口的引用指向实现类对象

封装

属性加private私有的修饰符，提供公有public修饰符修饰的方法，对外提供数据。

/*
创建手机类
    private:私有的 当前类自身可访问
    public:公有的，所有的类都可以访问
 */
public class Phone {
    //提供的私有的属性
    private String brand;//品牌
    private double price;//价格

    //提供公有的set方法
    public void setPrice(double price){
        if(price > 0){
            //this代表当前实例（对象） =  price(形参)
            this.price = price;
        }
    }
    //提供公有的getter方法
    public double getPrice(){
        return this.price;
    }

setter（用于设置数据，有参数，无返回值）

getter（用户获取数据，无参数，有返回值）

public class TestPhone {
    public static void main(String[] args) {
        Phone p1 = new Phone();
        p1.setPrice(-1000);
        System.out.println(p1.getPrice());
    }
}

练习

定义一个猫类(Cat), 包含颜色(color), 姓名(name)属性, 猫具有吃饭(eat), 睡觉(sleep),抓老鼠(catchMouse)的功能.

方法中只需要做输出即可.例如: eat功能 输出"xxx正在吃鱼", xxx是猫的name

采用封装的特征实现。（属性私有、提供公有的getter、setter方法对外提供数据）

package com.hl.pojo;
/*
定义一个猫类(Cat), 包含颜色(color), 姓名(name)属性,
猫具有吃饭(eat), 睡觉(sleep),抓老鼠(catchMouse)的功能.
方法中只需要做输出即可.例如: eat功能 输出"xxx正在吃鱼", xxx是猫的name
采用封装的特征实现。（属性私有、提供公有的getter、setter方法对外提供数据）
 */
public class Cat {
    //名称属性
    private String name;
    //颜色属性
    private String color;

    //自定义方法
    public void eat(){
        System.out.println(this.name+"---在吃东西");
    }

    public void sleep(){
        System.out.println(this.name+"---在睡觉");
    }

    public void catchMouse(){
        System.out.println(this.name+"---在捉老鼠");
    }


    //公有的getter、setter方法 (快捷键生成)
    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

package com.hl.pojo;

public class TestCat {
    public static void main(String[] args) {
        //创建对象
        Cat cat = new Cat();
        //调用set方法给属性赋值
        cat.setName("tomcat...");
        cat.setColor("咖啡色");
        //调用对象方法
        cat.eat();
        cat.sleep();
        cat.catchMouse();
    }
}

类和对象

类是抽象的，对象是具体的

封装

属性私有化，提供公有的getter、setter方法对外提供数据。 隐藏内部实现细节，提升安全性。

构造方法

目的：用于创建对象

分类：无参构造、有参构造

创建对象并给属性赋值：

无参构造+setter方法

有参构造方法

特点：

如果用户没有自定义构造方法，系统默认自动提供无参构造方法。如果用户自定义构造方法，系统不在提供无参构造。

构造方法，方法名和类名相同，不能定义返回值（也不能是void）

package com.hl.object;
/*
构造方法：目的是创建对象  在堆空间开辟空间，存储对象的属性值
构造方法的特点：
    方法名和类名相同，不能写返回值类型（既不能写int，short等，也不能写void）
构造方法的分类：
    无参构造：系统默认自动提供（如果用户自定义构造方法，系统不再提供默认构造方法），创建的对象,所有属性值为默认值
            整数：0  浮点：0.0 引用：null 布尔：false
            无参构造+setter方法 创建对象并给属性赋值
    有参构造：需要手动提供
 */
public class User {
    private int id;
    private String name;
    //无参构造方法
    //自定义构造方法，会覆盖系统自动提供的构造方法
    public User(){
        System.out.println("无参构造.....");
    }
    //有参构造方法  全参
    public User(int id,String name){
        this.id = id;
        this.name = name;
    }
    //有参构造方法
    public User(int id){
        this.id = id;
    }
    public static void main(String[] args) {
        //创建实例对象
        User user = new User();
        user.setId(1);
        user.setName("zhangsan");

        //利用有参构造方法创建对象的同时直接给属性赋值
        User user2 = new User(2,"lisi");

        System.out.println(user.getId()+"--"+user.getName());
        System.out.println(user2.getId()+"--"+user2.getName());
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

面向对象

三大思想：封装、继承、多态

封装思想：

public  class  Test{
    int id;
}
​
---> 提升系统安全性
​
public  class  Test{
    private int id;
    
    public int getId(){
        return this.id;
    }
    public void setId(int id){
        return this.id = id;
    }
}

继承思想：

public class Goods{
    //属性  id ,name ,price
    //方法  buy()  sell();
}
​
public class Phone{
    //属性  id ,name ,price
    //方法  buy()  sell();
}
​
public class TV{
    //属性  id ,name ,price
    //方法  buy()  sell();
}
​
----> 简化代码
​
public class Goods{
    //属性  id ,name ,price
    //方法  buy()  sell();
}
​
public class Phone extends Goods{
}
​
public class TV extends Goods{
}

多态思想：

1、简化代码
​
2、提升性能   spring--->IOC
​
public class Animal{}
public class Cat{}
public class Dog{}
public class Mouse{}
​
public class Person{
    raise(Animal a){}
    raise(Cat a){}
    raise(Dog a){}
    ---修改
    raise(Mouse m){}
}
​
---->简化代码
public class Person{
    raise(Animal a){}
}
​
​
---->父类的引用指向子类对象
Animal a = new Cat();
Cat c = new Cat();
Animal a = new Animal();

 继承

在java中，是单继承关系，一个类只能有一个直接父类,但是可以实现多重继承 A--->B--->C---->D

继承的关键字 extends

1、子类继承父类

子类可以继承父类的属性和方法，但是不能继承构造方法。私有的属性和方法不能直接使用。

2、关键字 this和super

相同点：都是关键字

区别：this代表当前实例对象 ， super不是对象，通过super关键字可以访问父类的构造方法，实例方法，实例变量。

this.属性名 调用当前实例属性 this.方法名可以调用实例方法 this() 调用构造方法

public class Animal {
    private String name;
    private int age;
    private String color;
    String hobby;

    public void eat(){
        System.out.println("eat.......");
    }
    public void drink(){
        System.out.println("drink......");
    }
    public Animal(){
        //构造方法无法继承
    }

    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;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

package com.hl.extendsDemo;

/*
在java中，是单继承关系，一个类只能有一个直接父类,但是可以实现多重继承
A--->B--->C---->D
 */
public class Dog extends Animal {

}

/*
 判断是否能够使用集成关系
 is  a
 cat is animal
 */
public class Cat extends Animal {

}

package com.hl.extendsDemo;

public class Test {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.eat();
        c.drink();
        c.hobby = "捉老鼠";


        Dog d = new Dog();
        d.eat();
        d.drink();
    }
}

this、super关键字

this是关键字，表示当前实例对象。

this.实例变量 访问实例变量

this.实例方法 访问实例方法

this() 访问构造方法 访问构造方法时只能出现在构造方法的第一行。

super，不是对象，只是关键字，用于访问父类的实例变量和实例方法以及在构造方法中访问父类的构造方法。

比较事项	this	super
访问实例变量	this.实例变量 访问本类中的实例变量	super.实例变量 访问父类中的实例变量（非私有）
访问实例方法	this.实例方法(…) 访问本类中的实例方法	super.实例方法(...) 访问父类中的实例方法（非私有）
访问构造方法	this(…) 调用本类中的构造方法，写在构造方法的第一行	super(...) 调用父类中的构造方法，写在构造方法的第一行
是否是对象	是对象，代表当前对象	不是对象，只是关键字

/*
 判断是否能够使用集成关系
 is  a
 cat is animal
 */
public class Cat extends Animal {
    //无参构造
    public Cat() {
        //访问父类的构造方法
        super();
        System.out.println("子类的无参构造....");
    }

    public void sleep(){
        super.eat();//访问父类实例方法
        String h = super.hobby;//访问父类实例变量
    }
}

public class Dog extends Animal {
    private String brand;

    public Dog() {
//        this("哈士奇");
        System.out.println("无参构造");
    }

    public Dog(String brand) {
        //在构造方法中出现，this()调用当前类的无参构造方法
        this();
        this.brand = brand;
        System.out.println("有参构造");
    }

    //实例方法
    public void lookDoor(){
        //this代表当前实例对象（调用实例方法的对象）
        System.out.println(this);
        System.out.println(this.brand);
        System.out.println(this.getAge());
        //调用当前实例对象的方法
        this.eat();
    }

package com.hl.extendsDemo2;

public class Test {
    public static void main(String[] args) {
//        Father f = new Father();
//        Son s1 = new Son();//创建子类对象
        Son s2 = new Son("河南");
    }
}

class Father{
    //私有的，子类无法直接访问
    private String name;
    //构造方法
    public Father() {
        System.out.println("父类无参构造.....");
    }
    public Father(String name) {
        this.name = name;
        System.out.println("有参构造方法");
    }

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

class Son extends Father{
    private String address;

    public Son(String address) {
        super("aaa");
        this.address = address;
        System.out.println("子类有参构造");
    }
    public Son() {
//        super();//调用父类的无参构造
        System.out.println("子类无参构造");
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

重写和重载的区别？

/*
方法重写  方法覆盖
前提条件：子类中重写父类方法
要求：方法名称相同，参数列表相同，返回值要求小于等于父类的返回值类型
效验：@Override  不报错
 */
@Override
public double area(){
    return this.width * this.height;
}

父类Person：
//实例方法
    public Person getPerson(){
        return this;
    }
//子类Student：
 	@Override
    public Person getPerson(){
        return new Person();
    }
    @Override
    public Student getPerson(){
        return new Student();
    }

方法重载：
前提条件：在同一个类中
要求：方法名称相同，参数列表不同，跟返回值无关

public double area(){
        return this.width * this.height;
}

public double area(double width, double height){
        return width*this.height;
}

多态

多态：指的是对象的多态性，同一对象在不同时刻表现出来的不同形态。

例如：猫

我们可以说猫是猫：猫 cat = new 猫();

也可以说猫是动物：动物 animal = new 猫();

这里猫在不同的时刻表现出来了不同的形态，就是多态。

场景1：父类的引用指向子类对象 , 编译找父类方法，运行执行子类内容。

动物 animal = new 猫();

场景2：接口的引用指向实现类对象

Usb usb = new Mouse();

对象数组

package com.hl.polymorphic;

public class objectArray {
    public static void main(String[] args) {
        Dog d1 = new Dog();
        d1.setName("发财");
        Dog d2 = new Dog();
        d2.setName("旺财");
        Dog d3 = new Dog();
        d3.setName("守财");

        //创建一个数组，存3只狗对象
        //数据类型[] 名称 = new 数据类型[3];
        Dog[] dogs = new Dog[3];
        dogs[0] = d1;
        dogs[1] = d2;
        dogs[2] = d3;

        //请遍历Dog数组，依次输出3只狗的名字
        for (int i = 0; i < dogs.length; i++) {
            Dog d = dogs[i];
            System.out.println(d.getName());
        }
    }
}

继承和多态综合练习1

package com.hl.polymorphic;

public class Animal {
    private String name;
    public void eat(){
        System.out.println("animal ..... eat");
    }
    public void sleep(){
        System.out.println("animal ..... sleep");
    }
}
//子类
class Dog extends Animal {
    @Override
    public void eat(){
        System.out.println("dog.....吃肉，吃骨头");
    }
}
//子类
class Bird extends Animal {
    @Override
    public void eat(){
        System.out.println("bird.....吃虫子");
    }
    public void sing(){
        System.out.println("bird.....sing唱歌");
    }
}

package com.hl.polymorphic;

public class TestAnimal {
    public static void main(String[] args) {
        //创建一个Animal对象，调用animal方法
        Animal a = new Animal();
        a.eat();
        a.sleep();

        Bird b = new Bird();
        b.eat();//子类重写父类的方法
        b.sleep();//继承父类的方法

        //父类引用指向子类对象   多态
        //一个对象表现多种形态  编译找父类方法，运行执行子类方法内容
        Animal a2 = new Bird();
        a2.eat();//子类重写
        a2.sleep();//父类的
//        a2.sing();//报错  编译找父类的  Animal中没有sing方法

//        父子类之间进行强制类型转换
        Bird b2 = (Bird)a2;
        b2.sing();

        Animal a3 = new Dog();
        //判断某个对象是否是指定的类型
        if(a3 instanceof Bird ){
            //强制类型转换异常
            Bird b3 = (Bird)a3;
            b3.sing();
        }else if(a3 instanceof Dog ){
            Dog d3 = (Dog)a3;
            d3.eat();
        }

    }
}

继承多态综合练习2

在上面的模块里, 在com.lanou.raise包里创建一个TestRaise类, 在类的main方法中测试下面编写的类(创建对象, 访问方法):

(1) 通过继承和多态完成人饲养动物. 需要定义人类Person, 动物类Animal(用于被Cat, Dog, Bird继承), 猫类Cat, 狗类Dog, 鸟类Bird.

Person类: 包含姓名name属性, raiseAnimal方法(此方法的参数是多态的, 可以是任意动物. 方法内部调用动物的eat方法)

Animal类: 包含姓名name属性, eat方法.

Cat类: 继承于Animal类, 重写eat方法, 添加抓老鼠catchMouse方法

Dog类: 继承于Animal类, 重写eat方法, 添加看门guardHouse方法

Bird类: 继承于Animal类, 重写eat方法, 添加捉虫子catchInsects方法

在TestRaise类的main方法里, 分别创建Person, Cat, Dog, Bird对象, 让person分别饲养cat, dog, bird.

(2) 在TestRaise类的main方法里, 创建一个数组,存放2只Cat, 1只Dog, 2只Bird.

数组可以定义成Animal数组, 这样就能通过多态存储不同类型的动物了.

(3) 在TestRaise类的main方法里, 遍历上述数组, 如果数组元素是Cat, 执行抓老鼠方法, 如果数组元素是Dog, 执行看门方法, 如果数组元素是Bird, 执行捉虫子方法.

package com.hl.work;

public class TestRaise {
    public static void main(String[] args) {
        //创建一个人
        Person p = new Person();
        //创建一只猫
        Cat c = new Cat();
        c.setName("波斯猫");

        Cat c2 = new Cat();
        c2.setName("加菲猫");
        //创建一只狗
        Dog d = new Dog();
        d.setName("阿拉斯加");
        //人喂动物
        p.raiseAnimal(c);
        p.raiseAnimal(d);
        //定义一个数组，存储猫狗鸟
        Animal[] animals = {c, c2, d};
        //遍历上述数组,
        // 如果数组元素是Cat, 执行抓老鼠方法,
        // 如果数组元素是Dog, 执行看门方法,
        // 如果数组元素是Bird, 执行捉虫子方法.
        for (int i = 0; i < animals.length; i++) {
            Animal a = animals[i];
            //判断a到底是什么数据类型
            if(a instanceof Dog){
                Dog dog = (Dog)a;
                dog.guardHouse();
            }else if(a instanceof Cat){
                Cat cat = (Cat)a;
                cat.catchMouse();
            }else if(a instanceof Bird){
                Bird bird = (Bird)a;
                bird.catchInsects();
            }
        }
//        int[] arrays = new int[3];
//        for (int i = 0; i < arrays.length; i++) {
//            int num = arrays[i];
//        }
    }
}
//参与者 Animal  Cat  Dog  Bird    Person
class Animal{
    //封装
    private String name;
    //方法
    public void eat(){
        System.out.println("----eat-----");
    }

    public Animal() {
    }

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

    //公有的getter、setter
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

class Dog extends Animal{
    //子类方法
    public void guardHouse(){
        System.out.println("dog...看门");
    }
    //重写父类方法
    @Override
    public void eat() {
        System.out.println(this.getName()+"dog 啃骨头....");
    }
}

class Cat extends Animal{
    //子类方法
    public void catchMouse(){
        System.out.println(this.getName()+"cat...捉老鼠");
    }
    //重写父类方法
    @Override
    public void eat() {
        System.out.println("猫 吃老鼠....");
    }
}
class Bird extends Animal{
    //子类方法
    public void catchInsects(){
        System.out.println("bird...捉虫子");
    }
    //重写父类方法
    @Override
    public void eat() {
        System.out.println(this.getName()+" 鸟吃虫子....");
    }
}

class Person{
    public void raiseAnimal(Animal animal){
        //调用动物吃东西方法
        animal.eat();
    }
}