封装
概念
把一些特征封装成属性,把一些行为封装成方法,将属性私有化,提供公共的方法访问私有属性
实现
私有化属性
setter方法给属性赋值
getter方法取值
有一个公共的无参数构造方法
public class Teacher {
private String name;//声明私有属性
private int age;
Teacher(String name,int age){
this.name=name;
this.age=age;
}
Teacher(){}
public void setName(String name){//通过set方法传参,给私有属性赋值
this.name=name;
}
public String getName(){//通过get方法,访问私有属性
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
继承
概念
把一些共同的属性和功能抽取成父类,子类继承这些共性
语法
class Animal{}
class Person extends Animal{}
继承哪些
方法
构造方法: 子类的构造方法里面自动调用父类隐式的无参构造方法
public class _01Test {
//这是一个主方法
public static void main(String[] args){
System.out.println("Hello World!");
//测试子类继承了父类隐式的无参构造方法
Student stu1=new Student();
//super调用父类的构造方法
Student stu2=new Student(20,"小明");
System.out.println(stu2.age);
}
}
class Person{
int age;
int tel=11110;
Person(){
System.out.println("父类的无参构造方法");
}
Person(int age){
this.age=age;
System.out.println("父类的有参构造方法");
}
}
class Student extends Person{
String name;
Student(){
System.out.println("子类的无参构造方法");
}
Student(int age,String name){
super(age);
this.name=name;
System.out.println("子类的有参构造方法");
}
}
静态方法: 不能被继承
普通方法: 私有的方法可以被继承,但不能直接访问
public class _03ExtendsDemo3 {
public static void main(String[] args){
Person per=new Person();
//per.name="小红";私有属性不能被直接访问
//System.out.println(per.name);
per.eat();//如果子类重写了方法,直接调用子类的
}
}
class Animal{
private String name;
private int age;
void eat(){
System.out.println("吃");
}
}
class Person extends Animal{
void eat(){
System.out.println("吃西餐");
}
}
字段
私有的字段可以被继承 不能直接访问
特点
- 单继承
- 多重继承
- 如果没有显式的继承某一个类,该类隐式继承了Object类
class A extends Object{
}
class B extends A{
}
class C extends B{
}
class D extends C{
}
方法覆写
概念
当父类中的方法不能满足子类的需求的时候, 子类重新实现方法中的功能
实现
- 子类中的方法名和父类一致
- 参数列表一致
- 返回值类型必须一致,子类中方法的返回值类型可以为父类方法中返回值类型的子类
- 子类方法的访问权限不能比父类的小
- @Override 覆写注解 用来检测方法是否满足覆写的要求
- static方法不能被覆写
public class _05OverrideDemo {
public static void main(String[] args){
System.out.println("Hello World!");
Person per=new Person();
per.eat();
}
}
class Animal{
private String name;
private int age;
Animal eat(){
System.out.println("吃");
return null;
}
}
class Person extends Animal{
@Override
public Person eat(){
//子类的访问权限高于父类
//子类的返回值类型是父类的返回值类型的子类
System.out.println("吃嘎嘎");
return null;
}
}
多态 polymorphism
概念
编译和运行时类型不一样
存在的前提: 必须有继承关系
使用
-
编译看左边
如果父类中没有该方法,会继续向上找,知道找到Object类中
- 找到:编译通过
- 找不到:编译不通过
-
运行看右边
运行时,先找子类的方法
- 找到:执行
- 找不到:向上到父类中找到并执行
有static修饰的,运行还是看左边
public class _03PolymorphicTest {
public static void main(String[] args){
System.out.println("Hello World!");
Animal a=new Person();
//编译看左边 当编译类型中没有该方法时去父类中找 直接找到Object为止
a.eat();//吃嘎嘎
test(a);//吃嘎嘎
//运行看右边
Person p=new Person();
test(p);//吃嘎嘎
Animal a1=new Animal();
test(a1);//吃东西
}
public static void test(Animal a){
a.eat();
}
}
class Animal{
void eat(){
System.out.println("吃东西");
}
}
class Person extends Animal{
void eat(){
System.out.println("吃嘎嘎");
}
}
引用类型转换
小转大
Cat c=new TomCat();
大转小 强制转换
TomCat tc=(TomCat)c;
判断类型
-
获得运行时类型
obj.getClass().getName()
-
类型判断
a instanceof A
对象a是否属于A类型,结果是布尔类型
public class _05TransformTest {
public static void main(String[] args){
System.out.println("Hello World!");
/*
引用数据类型转换 编译看左边 运行看右边
小转大
Cat c=new ACat();
大转小
ACat ac=(ACat) c;
*/
Cat c=new ACat();
ACat ac=(ACat)c;
ac.playMG();//变魔术
ACat ac1=(ACat) new Cat();//报错,当试图将对象强制转换为不是实例的子类时，抛出该异常。
//Exception in thread "main" java.lang.ClassCastException: Cat cannot be cast to ACat
Cat c1=new BCat();
//c1.Dance();//编译报错,Cat类型没有dance方法
test(c1);
test(c);
}
public static void test(Cat c){
/*
需求:
判断传入的参数对象是否是ACat类型
如果是,强转 调用方法
如果不是,打印一句话
方式1 获取c的运行类型
c.getClass().getName();
方式2 运用 instanceof
a instanceof A
判断a对象是否属于A类型 计算结果是布尔类型
*/
//方式1
/*if(c.getClass().getName().equals("ACat")){
ACat ac=(ACat)c;
ac.playMG();
}else{
System.out.println("you are not my partner");
}*/
//方式2
if(c instanceof ACat){
ACat ac=(ACat)c;
ac.playMG();
}else{
System.out.println("you are not my partner");
}
}
}
class Cat{
}
class ACat extends Cat{
void playMG(){
System.out.println("变魔术");
}
}
class BCat extends Cat{
void Dance(){
System.out.println("跳舞");
}
}