（一）final关键字
(1)是最终的意思，可以修饰类，方法，变量。 (2)特点： A:它修饰的类，不能被继承。 B:它修饰的方法，不能被重写。 C:它修饰的变量，是一个常量。 (3)面试相关： A:局部变量 a:基本类型 值不能发生改变 b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的 B:初始化时机 a:只能初始化一次。 b:常见的给值 定义的时候。(推荐) 构造方法中。
（二）多态
(1)同一个对象在不同时刻体现出来的不同状态。
(2)多态的前提：
A:有继承或者实现关系。
B:有方法重写。
C:有父类或者父接口引用指向子类对象。
多态的分类：
a:具体类多态
class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
b:抽象类多态
abstract class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
c:接口多态
interface Fu {}
class Zi implements Fu {}
Fu f = new Zi();
(3)多态中的成员访问特点
A:成员变量
编译看左边，运行看左边
B:构造方法
子类的构造都会默认访问父类构造
C:成员方法
编译看左边，运行看右边
D:静态方法
编译看左边，运行看左边
为什么?
因为成员方法有重写。
(4)多态的好处：
A:提高代码的维护性(继承体现)
B:提高代码的扩展性(多态体现)
(5)多态的弊端：
父不能使用子的特有功能。
现象：
子可以当作父使用，父不能当作子使用。
(6)多态中的转型
A:向上转型
从子到父
B:向下转型
从父到子
（三）抽象类
(1)把多个共性的东西提取到一个类中，这是继承的做法。 但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体不一样。 也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。 所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。 而一个没有具体的方法体的方法是抽象的方法。 在一个类中如果有抽象方法，该类必须定义为抽象类。 (2)抽象类的特点 A:抽象类和抽象方法必须用关键字abstract修饰 B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类 C:抽象类不能实例化 D:抽象类的子类 a:是一个抽象类。 b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。 (3)抽象类的成员特点： A:成员变量 有变量，有常量 B:构造方法 有构造方法 C:成员方法 有抽象，有非抽象 (4)抽象类的几个小问题 A:抽象类有构造方法，不能实例化，那么构造方法有什么用? 用于子类访问父类数据的初始化 B:一个类如果没有抽象方法,却定义为了抽象类，有什么用? 为了不让创建对象 C:abstract不能和哪些关键字共存 a:final 冲突 b:private 冲突 c:static 无意义
（四）接口
(1)回顾猫狗案例，它们仅仅提供一些基本功能。
比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，
是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。
(2)接口的特点：
A:接口用关键字interface修饰
interface 接口名 {}
B:类实现接口用implements修饰
class 类名 implements 接口名 {}
C:接口不能实例化
D:接口的实现类
a:是一个抽象类。
b:是一个具体类，这个类必须重写接口中的所有抽象方法。
(3)接口的成员特点：
A:成员变量
只能是常量
默认修饰符：public static final
B:构造方法
没有构造方法
C:成员方法
只能是抽象的
默认修饰符：public abstract
(4)类与类,类与接口,接口与接口
A:类与类
继承关系，只能单继承，可以多层继承
B:类与接口
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时，实现多个接口
C:接口与接口
继承关系，可以单继承，也可以多继承
(5)抽象类和接口的区别(自己补齐)?
A:成员区别
抽象类：
成员变量：可以变量、可以常量
构造方法：有
成员方法：可以抽象，可以非抽象
接口：
成员变量：只可以是常量
成员方法：只可以是抽象
构造方法：无
B:关系区别:
类与类：
继承，单继承
类与接口：
实现，单实现，多实现
接口与接口：
继承，单继承，多继承
C:设计理念不同
抽象类：is a，抽象类中定义的是共性功能。
接口：like a，接口中定义的是扩展功能。
案例
需求:人去宠物店领养()一个宠物(cat dog)
宠物:Cat和Dog 继承父类animal
成员属性:
姓名name
种类kind
性别sex
饱食度satiety
健康值health
成员方法:
eat()和独有的play()
注意:健康值和饱食度默认为60(0-100),
喂食增加20点饱食度，减去10点健康值
玩耍减去10点饱食度，增加20点健康值
接口
public interface Animalimpt {
void eat();
}
Animal类
public abstract class Animal implements Animalimpt {
private String name;
private String kind;
private String sex;
private int satiety=60;
private int health=60;
public Animal(String name, String kind, String sex) {
this.name = name;
this.kind = kind;
this.sex = sex;
}
public void setSatiety(int satiety) {
this.satiety = satiety;
}
public void setHealth(int health) {
this.health = health;
}
public int getSatiety() {
return satiety;
}
public int getHealth() {
return health;
}
public String getName() {
return name;
}
public String toString() {
return "Animal{" +
"name='" + name + '\'' +
", kind='" + kind + '\'' +
", sex='" + sex + '\'' +
", satiety=" + satiety +
", health=" + health +
'}';
}
}
Cat类
public class Cat extends Animal{
public Cat(String name, String kind, String sex) {
super(name, kind, sex);
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void catplay(){
System.out.println("猫玩球");
}
}
Dog类
public class Dog extends Animal {
public Dog(String name, String kind, String sex) {
super(name, kind, sex);
}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
public void dogplay(){
System.out.println("狗看门");
}
}
Person类
public class Person {
private Animal animal;
public void setAnimal(Animal animal) {
this.animal = animal;
}
public void cahkan(){
System.out.println(animal.toString());
}
public void feed(){
System.out.println("开始喂食");
if (animal.getSatiety()<100&&animal.getHealth()>0) {
animal.eat();
animal.setSatiety(animal.getSatiety()+20);
animal.setHealth(animal.getHealth()-10);
System.out.println("喂完食，当前饱食度为" + animal.getSatiety() );
System.out.println("喂完食，当前饱食度为" + animal.getHealth());
}
else {
System.out.println(animal.getName()+"无法被喂食");
}
}
public void test(){
System.out.println("开始玩耍");
if(animal.getHealth()<100&&animal.getSatiety()>0) {
if (animal instanceof Cat) {
((Cat) animal).catplay();
} else {
((Dog) animal).dogplay();
}
animal.setHealth(animal.getHealth()+20);
animal.setSatiety(animal.getSatiety()-10);
System.out.println("玩耍后，当前饱食度为"+animal.getSatiety());
System.out.println("玩耍后，当前健康值为"+animal.getHealth());
}
else{
System.out.println(animal.getName()+"无法玩耍");
}
}
}
Test类
public class Test {
public static void main(String[] args) {
Person p=new Person();
System.out.println("欢迎来到宠物店");
System.out.println("请选择要领养的动物：1.猫 2.狗");
Scanner scanner=new Scanner(System.in);
int a=scanner.nextInt();
switch (a){
case 1:
p.setAnimal(new Cat("花花","猫","女"));
break;
case 2:
p.setAnimal(new Dog("肉肉","狗","男"));
}
System.out.println("你选择宠物的信息如下");
p.cahkan();
boolean b=true;
while (b) {
System.out.println("请选择操作：1.玩耍 2.吃饭 3.退出");
Scanner scanner1 = new Scanner(System.in);
int j = scanner1.nextInt();
switch (j) {
case 1:
p.test();
break;
case 2:
p.feed();
break;
case 3:
b=false;
break;
}
}
}
}
编写程序实现比萨制作。需求说明编写程序，接收用户输入的信息，选择需要制作的比萨。可供选择的比萨有：培根比萨和海鲜比萨。
实现思路及关键代码
1)分析培根比萨和海鲜比萨
2)定义比萨类
3)属性：名称、价格、大小
4)方法：展示
5)定义培根比萨和海鲜比萨继承自比萨类
6)定义比萨工厂类，根据输入信息产生具体的比萨对象
Pizza类
public class Pizza{
private String name;
private int price;
private int size;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
public void show(){
System.out.println("名称："+getName());
System.out.println("价格："+getPrice());
System.out.println("大小："+getSize());
}
}
Baconic类
public class Baconic extends Pizza{
private int weight;
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
@Override
public void show() {
super.show();
System.out.println("培根克数"+getWeight());
}
}
seafood类
public class seafood extends Pizza {
private String string;
public String getString() {
return string;
}
public void setString(String string) {
this.string = string;
}
@Override
public void show() {
super.show();
System.out.println("配料："+getString());
}
}
Test类
public class Test {
public static void main(String[] args) {
Pizzastore p=new Pizzastore();
p.display();
}
}
案例：编写一个程序，实现如下类和功能
篮球运动员和乒乓球运动员，篮球教练和乒乓球教练
为了出国交流，有关乒乓球的人员都要学习英语
分析：从下往上 实现：从上往下
interface SpeakEnglish{
public abstract void speakEnglish();
}
abstract class People{
private String name;
private int age;
public People(){
}
public People(String name,int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return this.age;
}
abstract public void eat();
public void sleep(){
System.out.println("睡觉");
}
}
abstract class Player extends People {
public Player() {
}
public Player(String name, int age) {
super(name, age);
}
abstract public void study();
}
abstract class Coach extends People{
public Coach(){
}
public Coach(String name,int age){
super(name,age);
}
abstract public void teach();
}
class PingpangPlayer extends Player implements SpeakEnglish{
public PingpangPlayer(){
}
public PingpangPlayer(String name,int age){
super(name,age);
}
@Override
public void eat() {
System.out.println(getName()+"吃小白菜，喝小米粥");
}
@Override
public void study() {
System.out.println(getName()+"学习打乒乓球");
}
@Override
public void speakEnglish() {
System.out.println(getName()+"会说英语");
}
}
class BasketPlayer extends Player{
public BasketPlayer(){
}
public BasketPlayer(String name,int age){
super(name,age);
}
@Override
public void eat() {
System.out.println(getName()+"吃牛肉，喝牛奶");
}
@Override
public void study() {
System.out.println(getName()+"学习打篮球");
}
}
class PingpangCoach extends Coach implements SpeakEnglish{
public PingpangCoach(){
}
public PingpangCoach(String name,int age){
super(name,age);
}
@Override
public void eat() {
System.out.println(getName()+"吃大米粥，喝豆浆");
}
@Override
public void teach() {
System.out.println(getName()+"教打乒乓球");
}
@Override
public void speakEnglish() {
System.out.println(getName()+"会说英语");
}
}
class BasketCoach extends Coach{
public BasketCoach(){
}
public BasketCoach(String name,int age){
super(name,age);
}
@Override
public void eat() {
System.out.println(getName()+"吃肉，喝酒");
}
@Override
public void teach() {
System.out.println(getName()+"教打篮球");
}
}
public class InterfaceTest {
public static void main(String[] args) {
PingpangPlayer pingpangPlayer=new PingpangPlayer();
pingpangPlayer.setAge(25);
pingpangPlayer.setName("乒乓球运动员");
System.out.println(pingpangPlayer.getName()+"========="+pingpangPlayer.getAge());
pingpangPlayer.sleep();
pingpangPlayer.eat();
pingpangPlayer.study();
pingpangPlayer.speakEnglish();
System.out.println("====================");
BasketPlayer basketPlayer=new BasketPlayer("篮球运动员",32);
System.out.println(basketPlayer.getName()+"========="+basketPlayer.getAge());
basketPlayer.sleep();
basketPlayer.eat();
basketPlayer.study();
System.out.println("=====================");
PingpangCoach pingpangCoach=new PingpangCoach("乒乓球教练",36);
System.out.println(pingpangCoach.getName()+"========="+pingpangCoach.getAge());
pingpangCoach.sleep();
pingpangCoach.eat();
pingpangCoach.teach();
pingpangCoach.speakEnglish();
System.out.println("=====================");
BasketCoach basketCoach=new BasketCoach("篮球教练",43);
System.out.println(basketCoach.getName()+"========="+basketCoach.getAge());
basketCoach.sleep();
basketCoach.eat();
basketCoach.teach();
}
}
java入门基础学习（一）
java入门基础学习（二）
java入门基础学习（三）
java入门基础学习（四）
java入门基础学习（五）
java入门基础学习（六）
java入门基础学习（七）
java进阶之常见对象（一）
java进阶之常见对象（二）
java进阶之冒泡排序
java进阶之选择排序
java进阶之面向对象（封装）
java进阶之面向对象（代码块、继承）