/**
继承：
继承一个父类只能继承非私有的属性和方法；
protected访问权限修饰符在继承关系中使用，父类的属性和方法可以被继承
构造方法不能被继承
如果创建子类对象会调用父类默认构造方法
当父类中没有无参构造方法，子类必须显示调用父类有参构造方法，使用super()
*/
public class Test1 {
public static void main(String[] args) {
Cat c = new Cat("sansan");
System.out.println(c.name);
}
}
class Pet{
private int age;
protected String name;
public Pet() {
System.out.println("Pet构造方法");
}
public void eat(){
System.out.println("我能吃");
}
}
class Cat extends Pet{
public Cat(String name) {
this.name=name;
}
public void sleep() {
System.out.println("我能睡");
}
}
class Dog extends Pet{
public void run(){
System.out.println("我能跑");
}
}
/**
super:
1.super调用父类属性
2.super调用父类方法
3.super调用父类构造方法
*/
public class Test1 {
public static void main(String[] args) {
Cat c = new Cat(3,"SANSAN");
c.eat();
}
}
class Pet{
protected int age;
protected String name;
//public Pet() {}
public Pet(int age, String name) {
this.age = age;
this.name = name;
}
public void eat(){
System.out.println("我能吃");
}
}
class Cat extends Pet{
public Cat(int age,String name){
//调用父类构造方法(如果父类无参构造显示，则不需要用super调用)
super(age,name);
}
public void sleep() {
System.out.println("我能睡");
}
@Override
public void eat() {
//调用父类的方法
super.eat();
//super.属性 调用父类属性，如果继承了父类属性，super可省略
System.out.println("我是"+super.name+"我"+super.age+"岁我能吃鱼");;
}
}
/**
final关键字:
1.使用final声明一个属性就是常量，常量一般都用大写表示,必须在定义时或在构造器中初始化
2.使用final声明的方法只能被继承不能重写（最终方法）
3.final声明的类不能被继承
4.在方法参数中使用final，在该方法内部不能修改参数的值（内部类中详解）
*/
public class Test1 {
public static void main(String[] args) {
System.out.println(Constant.PERSON_NUM);
Constant constant = new Constant();
constant.printSize(3);
}
}
//常量类（属于工具类）
class Constant{
public static final int PERSON_NUM=10;//1
public final void print(){//2
System.out.println("final");
}
public void printSize(final int size){//4
final int z=100;//4
//size++;//无法操纵被final 声明的size
//z++;//无法操纵被final 声明的z
System.out.println(size);
System.out.println(z);
}
}
final class A{//3
}
/**
抽象类:用abstract关键字声明的类称为抽象类
1.抽象类可以没有抽象方法，有抽象方法的类必须是抽象类
2.非抽象类继承抽象类必须实现所有抽象方法
3.抽象类可以继承抽象类，可以不实现父类抽象方法
4.抽象类可以有方法实现和属性
5.抽象类不能被实例化
6.抽象类不能被声明为final
7.抽象类可以有构造方法
*/
public class Test1 {
public static void main(String[] args) {
Man man = new Man();
man.eat();
man.move();
}
}
abstract class Animal{
public abstract void move();
}
abstract class Person extends Animal{
public abstract void eat();
}
//继承抽象类的具体类必须实现抽象方法
class Man extends Person{
@Override
public void eat() {
System.out.println("我爱吃肉");
}
@Override
public void move() {
System.out.println("我爱跑步");
}
}
/**
接口
1.在一个接口中，只能定义常量、抽象方法，JDK1.8后可定义默认的实现方法
2.接口可继承多个接口，
3.一个具体类实现接口用implements关键字，可实现多个接口
4.抽象类实现接口可不实现接口方法
5.接口中定义的方法没有声明访问修饰符默认是public
6.接口不能有构造方法
7.接口不能被实例化
*/
public class Test1 {
public static void main(String[] args) {
Girl zhang = new Girl("zhang");
zhang.eat();
zhang.print();
}
}
interface IEat{
//public abstract void eat();//接口中只能定义抽象方法
void eat();//可简写，默认public abstract
//public static final int NUM=10;//在接口中定义一个常量
int NUM=10;//可简写
//在JDK1.8后新特性，可被所有实现类继承（几乎不用）
public default void print(){
System.out.println("eat");
}
}
interface IRun{
void run();
}
interface ISleep extends IEat,IRun{//接口之间多继承
void sleep();
}
class Girl implements ISleep,IEat{//类实现多个接口，必须实现所有方法
private String name;
public Girl() {}
public Girl(String name) {
this.name = name;
}
@Override
public void sleep() {
System.out.println("我爱睡觉");
}
@Override
public void eat() {
System.out.println("我是"+name+"，我爱吃饭");
}
@Override
public void run() {
}
}
/**
多态
1.方法的重载与重写就是方法的多态性表现
2.多个子类就是父类的多种形态
3.父类引用可以指向子类对象自动转换
4.子类对象指向父类引用需要强制转换（类型不对会报异常）
5.在实际开发中尽量使用父类引用（更利于扩展（随意增加多种鸡类））
*/
public class Test1 {
public static void main(String[] args) {
//用父类的引用指向子类的对象（）自动转换（向上转型）
Chicken hc = new HomeChicken("xiaoji");
Chicken yc = new YeChicken("juji");
Chicken jc = new JianjiaoChicken("jian");
eat(hc);
eat(yc);
eat(jc);
}
//抽象（粒度）面向抽象编程（传入鸡类的实例调用同一个eat方法结果却不同）父类一般是抽象类或接口
public static void eat(Chicken c){
c.eat();
//当需要把父类的实例强制转换为子类引用时，为避免类型转换异常，需要用instanceof判断
if (c instanceof JianjiaoChicken) {//如果传入的c是JianjiaoChicken的实例那么转换
JianjiaoChicken jc = (JianjiaoChicken) c;//大的类型转换为小类型，强制转换（向下转型）
jc.song();
}
}
}
abstract class Chicken{
private String name;
public Chicken() {}
public Chicken(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract void eat();
}
class HomeChicken extends Chicken{
public HomeChicken(String name) {
super(name);
}
public void eat(){
System.out.println(this.getName()+"，我爱吃米");
}
}
class YeChicken extends Chicken{
public YeChicken(String name) {
super(name);
}
public void eat(){
System.out.println(this.getName()+",我爱吃虫子");
}
}
class JianjiaoChicken extends Chicken{
public JianjiaoChicken(String name) {
super(name);
}
public void eat(){
System.out.println(this.getName()+",我不吃");
}
public void song(){
System.out.println("jijiji");
}
}
