第三周学习总结

（一）封装：

                不要直接对对象属性进行赋值，而是通过设置set/get方法进行赋值和取值

                好处：隐藏了内部实现的细节，提高安全性和复用性

                步骤：1.将赋值和取值变为set/get方法

                           2.属性私有化

        代码如下

class Book{
private String author;
private double price;
//set+属性名首字母大写，参数与属性名一致
public void setAuthor(String author) {
this.author = author;
}
//set+属性名首字母大写，返回值类型和对应属性一致
public String getAuthor() {
return author;
}
}

注意：封装是将属性封装成方法，所以方法的东西都能使用的，可以通过传参，方法体内设置准入条件等来尽量保证数据的正确性、合理性。

（二）继承：

                 两个类之间满足is a的关系，就可以使用继承，子类可以继承父类的属性，方法

                关键字extends

              优点：简化代码量，提高复用性  

                常见问题：继承能否有多继承（能不能有多个父亲）？    不能   （单继承）  

                                  能否有多级继承(有父亲，父亲的父亲)？         能     （间接继承）

代码如下

//祖父类
public class GranderFather {
String nameString;
String ageString;
String tuding;
String moneyString;
public void eat() {
System.out.println("吃饭");
}
}

public class Father extends GranderFather{
//父亲类继承祖父类
}

//儿子类继承父亲类，同时自身有自己独有的属性
public class Son extends Father{
String hairString;
}

//测试类，实例化儿子类，能调用父类继承的父类的方法和属性，也可以调用自身的属性和方法
public class Test {
public static void main(String[] args) {
Son son =new Son();
son.ageString="18";
son.eat();
son.mOneyString="2000";
son.hairString="red";
}
}

注意：不能被继承的情况：
                1.私有的特征和行为
                2.构造方法---最好测带参构造

另外，不管咋样都有个Object类（老祖宗类）

补充一：访问修饰符

 补充二：重写

                重写概述：1.子类方法和父类方法完全一致：返回值类型，方法名，参数列表
                                  2.子类权限大于等于父类权限

                应用场景：当父类的方法不适用子类时，子类可重写父类的方法；

                                那么调用时调的是子  类重写方法

 补充三：super关键字（以及和this的异同）

                super关键字的用法与this相似：
                this：当前对象 
                用法：
                this.属性： 调当前对象的属性，如果当前对象没有该属性，根据继承性可调父类的属性                 this.方法()：同上  
                this()：调当前对象的构造方法
                super：父类对象  
                用法：
                super.属性--调父类的属性
                super.方法()--调父类的方法
                super()----调父类的构造方法

 （三）多态（重点）：

                 万变不离其宗：父类引用指向子类对象，即形成了多态

                多态的前提： 一定要有继承关系

        多态方式1： 直接的父类引用指向子类对象

                        （父类引用指向子类对象，可调用子类重写方法）

                        父类引用可以调父类的方法;如果子类有重写方法，则优先调子类重写方法
                              父类引用不能调子类独有的方法

代码如下（======分隔不同的类）

public class Animal {
public void jiao() {
// TODO 自动生成的方法存根
System.out.println("叫声种类太多");
}
}
=======================================
public class Dog extends Animal{
@Override
public void jiao() {
System.out.println("汪汪汪~好兄弟快带我回家");
}
}
=======================================
public class Cat extends Animal{
@Override
public void jiao() {
System.out.println("喵喵喵~铲屎官快带我回家");
}
}
=======================================
public class Bird extends Animal{
@Override
public void jiao() {
System.out.println("啾啾啾~快带我回家");
}
}
=======================================
//好兄弟们我就没写注释了，应该能看懂吧
//先定义了父类引用，在循环里面再通过不同的输入结果指向不同的子类对象
//这样父类可以不做变更，有啥要加的，再加个别的动物来卖，生成一个类继承就完事了
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Scanner scanner = new Scanner(System.in);
System.out.println("请输入想要购买的宠物：1猫，2狗，3鸟");
Animal animal;
int i;
int cOndition= 0;
while (condition <= 3) {
i = scanner.nextInt();
switch (i) {
case 1:
animal = new Cat();
animal.jiao();
condition++;
break;
case 2:
animal = new Dog();
animal.jiao();
condition++;
break;
case 3:
animal = new Bird();
animal.jiao();
condition++;
break;
default:
System.out.println("不买别捣乱，穷鬼");
condition++;
break;
}
}
}
}


还未总结完，回头再补上【狗头保命】