JavaSE 01 类和对象|继承多态

java基础

1、搭建环境  jdk、idea2、语法基础数据类型：基本 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...elseswitch(byte|short|int|string|char|枚举){case 1:sout;break;default:}
4、循环结构for  明确循环次数while  break;continue; do...whilebreak;5、循环嵌套和数组for(){for(){}}for(){while(){}}while(){do...while(){}}6、数组  一维数组、二维数组二维数组：底层一维数组，一维数组的每一个元素又是一个一维数组。7、方法（方法定义、方法调用）方法参数返回值调用public static void m1(int i){}  //形参  imain(){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  acat 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，不是对象，只是关键字，用于访问父类的实例变量和实例方法以及在构造方法中访问父类的构造方法。

/*判断是否能够使用集成关系is  acat 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：@Overridepublic Person getPerson(){return new Person();}@Overridepublic 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 {@Overridepublic void eat(){System.out.println("dog.....吃肉，吃骨头");}
}
//子类
class Bird extends Animal {@Overridepublic 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、setterpublic String getName() {return name;}public void setName(String name) {this.name = name;}
}class Dog extends Animal{//子类方法public void guardHouse(){System.out.println("dog...看门");}//重写父类方法@Overridepublic void eat() {System.out.println(this.getName()+"dog 啃骨头....");}
}class Cat extends Animal{//子类方法public void catchMouse(){System.out.println(this.getName()+"cat...捉老鼠");}//重写父类方法@Overridepublic void eat() {System.out.println("猫 吃老鼠....");}
}
class Bird extends Animal{//子类方法public void catchInsects(){System.out.println("bird...捉虫子");}//重写父类方法@Overridepublic void eat() {System.out.println(this.getName()+" 鸟吃虫子....");}
}class Person{public void raiseAnimal(Animal animal){//调用动物吃东西方法animal.eat();}
}