1.构造代码块和构造方法的区别
｛
代码块
｝
public 类名 () {
}
都是实例化一个对象的时候执行的
只不过构造代码块先于构造方法执行的
2.局部变量和成员变量区别
局部变量写在方法中，只能在方法体中使用，出了这个方法就不能再使用了
成员变量写在类中，整个类都可以使用的。
3.声明类的语法格式
class 类名 {
属性
构造方法
方法
}
4.一个类中属性的意义是啥
用来描述一个类的特征的，可以通过对象对这个特征进行赋值的
5.构造方法的语法格式
public 类名 () {
}
public 类名 (参数) {
}
6.逻辑运算符的简单介绍
7.封装
1.对成员变量加修饰符 private
2.一定要写setter和getter方法进行赋值和取值即可
8.this关键字
1.this关键字可以调用成员属性和方法
2.this还可以调用构造方法
9.一个类对象作为方法的参数
10.多类合作
今天的内容
1.多类合作几个全部讲
2.继承
3.继承的内存分析
4.重写和重载
1.
部门类
员工类
部门类下面有员工
2.
老师类
学生类
老师带了很多学生 把学生存倒数组中 STudent[] stus = new Student[6];
3.
成年人类
孩子类
玩具类
4.
需求：
两个宠物一个狗一个猫宠物饿了，需要主人给宠物喂食
1.不同的宠物吃的不同
2.不同的宠物吃完食体力值增加
3.主人和狗玩游戏 接飞盘的游戏。狗体力值减去10，但是会和主人的亲密度提升5
4.主人和猫玩游戏 滚毛球。猫体力值减去12 ，但是会和主人的亲密度提升7
人类
猫类
package com.qfedu.a_homework;
//部门类
class Department {
private String depId;//部门id
private String deptName;//部门的名字
private Employee employee;//部们下面的员工
public String getDepId() {
return depId;
}
public void setDepId(String depId) {
this.depId = depId;
}
public String getDeptName() {
return deptName;
}
public void setDeptName(String deptName) {
this.deptName = deptName;
}
public Employee getEmployee() {
return employee;
}
public void setEmployee(Employee employee) {
this.employee = employee;
}
}
//员工类
class Employee {
private String name;//员工的名字
private int age;//员工的年龄
private char sex;//员工的性别
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 char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}
public class Demo1 {
public static void main(String[] args) {
//创建Employee对象
Employee employee = new Employee();
employee.setName("张三");
employee.setAge(28);
employee.setSex('男');
//先创建部门对象
Department department = new Department();
//对department对象属性进行赋值
department.setDepId("0001");
department.setDeptName("研发部");
department.setEmployee(employee);
//以上是在赋值
//取值
//想要部门的id
System.out.println(department.getDepId());
//想要获取部门的名字
System.out.println(department.getDeptName());
//想要获取部门下面的员工对象,会打印的啥? 会打印的是地址！！！
System.out.println(department.getEmployee());
//能够获取出来employe对象了。
//能不能获取emplopyee对象的属性值呢?
System.out.println("员工的名字:" +department.getEmployee().getName());
System.out.println("员工的年龄:" + department.getEmployee().getAge());
System.out.println("员工的性别:" + department.getEmployee().getSex());
}
}
package com.qfedu.a_homework;
class Teacher {
private String name;//老师的姓名
private char sex;
private int age;
//老师下面有很多的学生 Student[] stus = new Student[3];
private Student[] student;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student[] getStudent() {
return student;
}
public void setStudent(Student[] student) {
this.student = student;
}
}
class Student {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class Demo2 {
public static void main(String[] args) {
Student[] stus = new Student[2];//现在数组是一个空的
//对数组进行赋值
Student student = new Student();
student.setName("骚磊");
Student student2 = new Student();
student2.setName("老万");
stus[0] = student;
stus[1] = student2;
//脑海里面 想到stus是一个容器 数组， 里面已经放了两个值了
//两个对象
Teacher teacher = new Teacher();
teacher.setName("老邢");
teacher.setAge(89);
teacher.setSex('女');
//现在setStudent的参数是一个数组
//stus里面有值了 两个对象student
teacher.setStudent(stus);
//以上都是在赋值
//取值
Student[] students = teacher.getStudent();
for (int i = 0; i < students.length; i++) {
System.out.println(students[i].getName());
}
}
}
package com.qfedu.a_homework;
class Adult {
private String name;//成年人的名字
private Child child;//成年人下面的孩子对象
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Child getChild() {
return child;
}
public void setChild(Child child) {
this.child = child;
}
}
class Child {
private String name;
private int age;
private Toy toy;
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 Toy getToy() {
return toy;
}
public void setToy(Toy toy) {
this.toy = toy;
}
}
class Toy {
private String name;//玩具的名字
private double price;//玩具的价格
private String kind;//玩具的种类
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getKind() {
return kind;
}
public void setKind(String kind) {
this.kind = kind;
}
}
public class Demo3 {
public static void main(String[] args) {
Toy toy = new Toy();
toy.setName("骚奥特曼");
toy.setPrice(67.8);
toy.setKind("皮套");
Child child = new Child();
child.setName("小骚磊");
child.setAge(1);
child.setToy(toy);
Adult saolei = new Adult();
saolei.setName("骚磊");
saolei.setChild(child);
//以上都是在赋值
//取值
//需求
//通过成年人找到孩子的名字
//saolei.getChild()获取孩子对象 .getName
System.out.println(saolei.getChild().getName());//获取孩子的名字
System.out.println(saolei.getChild().getAge());//获取孩子的年龄
//通过成年人获取玩具的种类 名字 价格的
System.out.println(saolei.getChild().getToy().getName());
System.out.println(saolei.getChild().getToy().getKind());
}
}
1.继承
Java 有三大特性: 封装 继承 多态
1.1.生活中的继承
子承父业
龙生龙 凤生凤
老鼠生来会打洞
你长得真像你父亲
1.2.Java中继承
继承是类和类之间的关系
继承至少得两个类：
语法格式:
class B extends A { }其中 B是一个类，A是一个类
B类继承了A类。 B叫A的子类。A是B的父类（超类，基类）
入门案例:
package com.qfedu.b_extends;
class Father {
String name;
int age;
//行为
public void eat () {
System.out.println("吃大盘鸡拌面");
}
}
//使用了extends以后 Son 类就继承了Father这个类
//就意味着我Son类可以使用Father类下面某些属性和某些方法
class Son extends Father{
}
public class Demo1 {
public static void main(String[] args) {
Son son = new Son();
//发现继承以后，可以使用父类一些属性
son.name = "小骚磊";
son.age = 1;
System.out.println(son.name);
System.out.println(son.age);
son.eat();
}
}
案例:
Animal 类 父类
Dog类 子类
Cat类 子类
继承的意思，就是将父类的属性和方法拿到子类中去使用
1.成员变量（属性）
公开的和默认的属性，子类可以继承使用的
私有的成员变量，子类无法使用的
2.成员方法
公开的和默认的成员方法，子类可以继承使用
私有的成员方法，子类无法使用的
总结：凡是私有的 无法继承。
3.构造方法
先执行父类的构造，再执行子类的构造方法
如果父类中有有参构造，但是没有无参构造。子类会报错
关于构造方法：父类与子类的构造方法的形式保持一致。
父类中有无参构造。子类也有无参构造。父类中没有无参构造，子类也没有无参构造方法
package com.qfedu.c_extends;
class Father {
//只要是公开的或者默认的属性，子类可以使用的
public String name;//公开的一个属性
int age;//就是默认的属性
private int id;//private修饰的 子类不能使用
public Father () {
System.out.println("父类的构造方法");
}
public Father (String name) {
this.name = name;
}
//eat方法 使用public修饰的 子类可以使用
public void eat () {
System.out.println("吃窝窝头");
}
//默认的方法 子类是可以使用的
void work () {
System.out.println("开拖拉机耕地");
}
// 使用private修饰的方法就是私有化的方法，子类能调用吗？不能
private void smoking () {
System.out.println("抽旱烟");
}
}
class Son extends Father {
//在子类写有参构造即可
}
public class Demo1 {
public static void main(String[] args) {
Son son = new Son();
//验证name age在子类中可以使用的
son.name = "狗蛋";
son.age = 12;
//son.id = 12;
son.eat();//可以使用父类的公开的方法
son.work();
//不可以使用父类私有化的方法
//.son.smoking();
}
}
刚才在写代码的时候，发现私有成员变量子类不能用。还有私有化的方法子类不能调用。咋办？
package com.qfedu.c_extends;
class Father1 {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private void smoking () {
System.out.println("抽旱烟");
}
public void test () {
smoking();
}
}
class Son1 extends Father1 {
}
public class Demo2 {
public static void main(String[] args) {
Son1 son1 = new Son1();
//咋办？ 可以使用setter和getter方法
//son1.name = "";
son1.setName("狗蛋");
System.out.println(son1.getName());
son1.test();
}
}
练习的案例:
Animal 类:
属性 : name, age ,sex 私有化的
方法: 吃 运动
子类：Panda
使用Panda继承Animal 并可以使用Animal下面的所有属性和方法，对属性进行赋值
方法调用
package com.qfedu.c_extends;
class Animal {
private String name;
private int age;
private char sex;
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 char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
//方法
public void eat () {
System.out.println("吃饭");
}
public void sport () {
System.out.println("运动");
}
}
class Panda extends Animal {
}
//继承有啥好处呢？代码可以重复利用
class Cat extends Animal {
}
class Dog extends Animal {
}
public class Demo3 {
public static void main(String[] args) {
Panda panda = new Panda();
panda.setName("熊大");
panda.setAge(9);
panda.setSex('公');
panda.eat();
panda.sport();
}
}
继承:
Java中的继承都是单继承。只能有一个父类
Java中可以多重继承
package com.qfedu.c_extends;
class A {
}
class B extends A{
}
class C extends B {
}
public class Demo4 {
public static void main(String[] args) {
}
}
总结：
1.至少两个类，使用关键字extends
2.子类是否能使用父类的成员变量和成员方法
子类不能使用父类私有化的所有的东西
1.3关于父类子类的内存分析
1.4重写【重点】
Override
重写目的：子类可以继承父类的非私有化的方法，但是有的 时候父类的需求满足不了子类的需求了，这个时候需要重写父类非私有的方法
重写要求：
1.必须有继承关系 2.父类的方法必须是非私有化的 3.在子类中重写父类的方法，这个方法除了方法体不一样其他都一样的。 4.必须再子类中去重写
package com.qfedu.d_override;
class Father {
public void eat () {
System.out.println("吃粗粮。。。。。。");
}
public void driver () {
System.out.println("开拖拉机。。。。。");
}
}
//当父类不能满足子类的需求的话可以在子类中重写父类的方法
class Son extends Father {
//重写的时候在子类中 只需要打上方法的名字一敲回车即可
//重写的方法 和父类 的 返回值 参数 方法名字 一模一样，但是方法体不一样的
@Override//是重写的严格限定，只要有这个，就证明咱们下面的这个方法
//就是重写的方法，告知程序员 此时eat方法是重写的不是自己独有的
public void eat() {
System.out.println("吃白面馒头......");
}
@Override
public void driver() {
System.out.println("开小汽车");
}
}
public class Demo1 {
public static void main(String[] args) {
Son son = new Son();
son.eat();
son.driver();
//重写的话，是不影响父类的方法的
Father father = new Father();
father.eat();
father.driver();
}
}
案例：
父类： 交通工具： 方法 run(); 两个子类: 飞机： 方法 run() 高铁: 方法 run() 公交车: 方法 run()
package com.qfedu.d_override;
class Transportation {
public void run () {
System.out.println("可以跑......");
}
}
class Fly extends Transportation {
//是继承 我就u可以重写父类下面的方法了
@Override//开启重写的严格的限制，告知编译器，下面的方法必须是重写的
public void run () {
System.out.println("飞机跑的很快大概500km/h");
}
}
class Train extends Transportation {
@Override
public void run() {
System.out.println("在铁轨上跑的300km/h");
}
}
class Bus extends Transportation {
@Override
public void run() {
System.out.println("在公路上跑的60km/h");
}
}
public class Demo2 {
public static void main(String[] args) {
Train train = new Train();
train.run();
}
}
1.5重载【overload】
在Java中同一个类中可以有很多个方法。方法名字一样。但是参数类型不一样。这种叫重载
总结：
1.方法的重载必须在同一个类中 2.方法名字必须一致 3.方法的参数类型必须不一样 4.方法的返回值可以不一样 5.无参构造和有参构造 也是一种重载面试题: 重写和重载的区别
package com.qfedu.d_override;
class Person {
//在一个类中，方法法名字一样，但是参数一定不一样。这叫方法的重载
//返回值可以不一样
public void test () {
System.out.println("test");
}
public void test (String name) {
System.out.println(name);
}
public void test (int i) {
System.out.println(i);
}
void test (double d1) {
}
public String test(String str1, String str2) {
return str1 + str2;
}
}
public class Demo3 {
public static void main(String[] args) {
}
}
作业：
1.把今天的消化掉
2.布置一些作业
String[] args) {
Train train = new Train();
train.run();
}
}
#### 1.5重载【overload】
> 在Java中同一个类中可以有很多个方法。方法名字一样。但是参数类型不一样。这种叫重载
>
> 总结：
>
> ```
> 1.方法的重载必须在同一个类中
> 2.方法名字必须一致
> 3.方法的参数类型必须不一样
> 4.方法的返回值可以不一样
> 5.无参构造和有参构造 也是一种重载
> ```
>
> 面试题: 重写和重载的区别
```Java
package com.qfedu.d_override;
class Person {
//在一个类中，方法法名字一样，但是参数一定不一样。这叫方法的重载
//返回值可以不一样
public void test () {
System.out.println("test");
}
public void test (String name) {
System.out.println(name);
}
public void test (int i) {
System.out.println(i);
}
void test (double d1) {
}
public String test(String str1, String str2) {
return str1 + str2;
}
}
public class Demo3 {
public static void main(String[] args) {
}
}
作业：
1.把今天的消化掉
2.布置一些作业
