封装
private int age（私有 类名称 属性名称）。特别注意的是数组也属于java类。private 可以封装类、属性、方法。
继承
1、子类可以直接继承父类的操作，并且子类还可以继续扩充自己的功能。
package practice;
class A{
private String name;
private int 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;
}
}
class B extends A{
private String school;
public void setSchool(String school){
this.school = school;
}
public String getSchool(){
return this.school;
}
}
public class exte {
public static void main(String [] args){
A a = new A();
B b = new B();
a.setName("张三");
a.setAge(23);
b.setSchool("大学也");
System.out.println("姓名："+a.getName()+",年龄："+a.getAge()+"，学校："+b.getSchool());
}
}
2、Java不允许多重继承，允许多层继承。
//此为错误继承
class A{
}
class B{
}
class C extends A,B{
}
//这是对的
class A{
}
class B extends A{
}
class C extends B{
}
3、子类构造调用一定会先执行父类操作，显式/隐式操作
package practice;
class A1{
private String name;
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
}
class B1 extends A1{
/*public void fun(){
System.out.println(name); //这里用super.name调用也不对，私有属性只能在本类使用，父类不可使用
} */ //此方法操作错误，B1的name隐式继承乐A1的name，不能直接对私有属性进行操作，而可以隐式继承
}
//可以这样理解把A1当作父亲，B1当作孩子，
public class exten {
public static void main(String [] args){
B1 b = new B1();
b.setName("张三");
System.out.println(b.getName());
}
}
super() 操作/this()操作；没有无参构造时使用super()
package practice;
class D{
public D(){
System.out.println("A");
}
}
class E extends D{
public E(){
super(); //若父类有无参构造，加不加都可以，子类对象实例化时会默认调用父类的无参构造
System.out.println("B");
}
}
public class ex1 {
public static void main(String [] args){
new E();
}
}
-----------------------------------------------------------------------------------
package practice;
class D{
public D(String title){
System.out.println("A");
}
}
class E extends D{
public E(String title){
super(title); // this（）当前类中查找，extends（）父类查找，向父类查找
System.out.println("B");
}
}
public class ex1 {
public static void main(String [] args){
new E("d");
}
}
多态
两种形式描述：
方法的多态性：方法的重载，同一个方法名称，会根据传入参数的类型及个数的不同执行不同的方法体；方法的覆写：同一个方法会根据子类的不同，实现不同的功能。
对象的多态性：指的是发生在继承关系类中，子类和父类的转换。
向上转型：父类 父类对象 = 子类实例； //自动完成
向下转型：子类 子类对象 = （子类）父类实例。 //强制完成
向上转型：
class A{
public void print(){
System.out.println("A");
}
}
class B extends A {
public void print(){
System.out.println("B");
}
}
------------------------------------------------------
//向上
public class Duo{
public static void main(String [] args){
A a = new B();
a.print();
}
}
-------------------------------------------------------
//向下
public class Duo{
public static void main(String [] args){
A a = new B();
B b = (B)a;
b.print();
}
}
向上转型可以实现参数的统一
class A{
public void print(){
System.out.println("A");
}
}
class B extends A {
public void print(){
System.out.println("B");
}
}
class C extends A{
public void print(){
System.out.println("C");
}
}
public class Duo{
public static void main(String [] args){
//子类均可以用父类接受
A a1 = new B();
A a2 = new C();
a1.print();
a2.print();
}
}
向下转型：指的是父类要调用子类自己的特殊的方法。
class A{
public void print(){
System.out.println("A");
}
}
class B extends A {
public void print(){
System.out.println("B");
}
public void fun(){
System.out.println("fun");
}
}
public class Duo{
public static void main(String [] args){
A a1 = new B();
B b = (B)a1;
b.fun();
}
}
扩充方法
class A{
public void print(){
System.out.println("A");
}
}
class B extends A {
public void print(){
System.out.println("B");
}
public void fun(){
System.out.println("fun");
}
}
public class Duo{
public static void main(String [] args){
funa(new B());
}
public static void funa(A a){
B b = (B)a;
b.fun();
}
}
两个没有关系的类的对象强制向下转型时所带来的异常
Exception in thread "main" java.lang.ClassCastException: A cannot be cast to B
at Duo.main(Duo.java:14)
class A{
public void print(){
System.out.println("A");
}
}
class B extends A {
public void print(){
System.out.println("B");
}
}
public class Duo{
public static void main(String [] args){
A a = new A(); //A a = new B();
B b = (B)a;
b.print();
}
}
