1.继承
2.多态
3.final
4.重载与覆写
5. this/super
6.抽象类
7.接口
java:
private String name;
private int age;
public Person(){
System.out.println("Person");
}
public Person(String arg){
System.out.println(arg);
}
//this关键字的时候强调过一句话：如果一个类之中有多个构造方法之间使用this()互相调用的话，
//那么至少要保留有一个构造方法作为出口，而这个出口就一定会去调用父类构造。
//
// 此时在某种程度上来讲，有一个问题解释了一半：一个简单Java类一定要保留有一个无参构造方法。
//由于java不管理内存，无析构函数
/*
~Person(){
System.out.println("~Person");
}
*/
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;
}
//覆写方法,被覆写的方法不能拥有比子类更严格的权限
//private < default < public
public void show(){
System.out.println("Person show");
System.out.println(this.getAge());
System.out.println(this.getName());
}
};
//不允许多重继承，一个子类只允许继承一父类。
class Man extends Person{
private int weight;
private int hight;
Man(){
// 必须放有第一行
// super调用父类构造的时候，一定要放在构造方法的首行上。
super("super");
System.out.println("Man");
}
Man(String arg){
// 必须放有第一行
// super调用父类构造的时候，一定要放在构造方法的首行上。
//super("super");
this();//调用本类构造
System.out.println("Man");
}
public void setWeight(int weight){
this.weight = weight;
}
public int getWeight(){
return this.weight;
}
public void setHight(int hight){
this.hight = hight;
}
public int getHight(){
return this.hight;
}
public void show(){
//如果要调用被覆写过的父类的方法super()
//· this.方法()：先从本类查找是否存在指定的方法，如果没有找到，则调用父类操作；
//· super.方法()：直接由子类调用父类之中的指定方法，不再找子类。
//覆写发生在继承关系中，注意权限，参数个数，权限不能比父类严格，函数名称，返回值
//重载发生在一个类中，无权限要求，参数个数或是类型不同，返回值不能确定是否是重载
//super.show();
System.out.println("Man show");
System.out.println(this.getWeight());
System.out.println(this.getHight());
}
};
abstract class Woman{
private boolean ispre;
public int longth;
Woman(int longth){
this.longth = longth;
}
public abstract boolean getIspre();
}
class ImpWoman extends Woman{
ImpWoman(int a){
super(a);
}
public boolean getIspre(){
if(super.longth>15)
return true;
else
return false;
}
}
public class InheritTest{
public static void main(String args[]){
Man man = new Man();
Person per= new Person();
per.setAge(1000);
man.setWeight(10000);
per.show();
//子类在调用时调用的都是覆写函数
man.show();
System.out.println("=======================================");
//System.out.println(man.getAge());
//C+＋可以进行类型强转，java 相同
Person pper = new Man() ;//向上转型
pper.show();
Man mman = null;
mman = (Man)pper;
if(pper instanceof Person)
System.out.println("true");
else
System.out.println("false");
if(per instanceof Man)
System.out.println("true");
else
System.out.println("false");
// · 向下转型，10%，因为在进行向下转型操作之前，一定要首先发生向上转型，以建立两个对象之间的联系，如果没有这种联系，是不可能发生向下转型的，一旦发生了运行中就会出现“ClassCastException”，当需要调用子类自己特殊定义方法的时候，才需要向下转型；
// Man mman = (Man)new Person();//向下转型
/*
Man mman = new Person();
mman.show();
*/
//抽象类不能被实例化
//Woman woman = new Woman(23);
//抽象类之中可以没有抽象方法，但是反过来讲，如果有抽象方法，则一定是抽象类，即使抽象类之中没有抽象方法，也不能够被直接实例化
ImpWoman impwoman = new ImpWoman(23);
if(impwoman.getIspre())
System.out.println("true");
}
}
#include <string>
#include <stdlib.h>
using namespace std;
class Person{
private:
string name;
int age;
public:
Person(){
cout<<"Person"<<endl;
}
~Person(){
cout<<"~Person"<<endl;
}
void setName(string name){
this->name = name;
}
string getName(){
return this->name;
}
void setAge(int age){
this->age = age;
}
int getAge(){
return this->age;
}
};
class Cloth{
private:
int color;
int longth;
public:
void show();
};
//C++方法可以在类内部声明，外部定义，java则不可以
void Cloth::show(){
cout<<"test"<<endl;
}
//只能用于继承的类，不能用于实例化的类。
//父类中无法确定具体实现的成员函数称为纯虚函数。纯虚函数是一种特殊的虚函数，
//它只有声明，没有具体的定义。抽象类中至少存在一个纯虚函数；存在纯虚函数的类一定是抽象类。存在纯虚函数是成为抽象类的充要条件。
// virtual 返回值类型成员函数名（参数表）=0；
// 拥有纯虚函数的类称之为抽象类
class Animal{
private:
int type;
int age;
bool hair;
public:
Animal(int type,int age,bool hair){
this->type = type;
this->age = age;
this->hair = hair;
}
void setType(int type){
this->type = type;
}
void setAge(int age){
this->age = age;
}
int getType(){
return this->type;
}
int getAge(){
return this->age;
}
virtual void show() = 0;
};
class Dog:public Animal{
private:
int legs;
public:
Dog(int type,int age,bool hair,int legs):Animal(type,age,hair),legs(legs){}
//纯虚函数可以被覆写,必须被覆写
void show(){
cout<<"legs :"<<this->legs<<endl;
}
};
//c++允许多重继承，一个子类可以继承多个父类
class Man:public Person,public Cloth{
private:
int weight;
int hight;
public:
Man(){
cout<<"Man"<<endl;
}
~Man(){
cout<<"~Man"<<endl;
}
void setWeight(int weight){
this->weight = weight;
}
int getWeight(){
return this->weight;
}
void setHight(int hight){
this->hight = hight;
}
int getHight(){
return this->hight;
}
};
int main(int argc,char *argv[]){
Man man;
man.setAge(10);
cout<<man.getAge()<<endl;
//抽象类不能被实例化
//Animal animal(0,0,true);
Dog dog(1,12,true,4);
dog.show();
}
java:
class Person{
private String name;
private int age;
final int read = 5;
public void setName(String name){
this.name = name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this.age;
}
};
public class FinalTest{
public static void main(String args[]){
Person per = new Person();
//不能被修改
//per.read = 10;
System.out.println(per.read);
}
}
#include <string>
using namespace std;
//final 声明的类不能有子类，声明的方法不能被子类覆写，声明的变量是常量，不能被修改
class Person{
private :
string name;
int age;
public:
const int read ;
Person(int a):read(a){}
void setName(string name){
this->name = name;
}
void setAge(int age){
this->age = age;
}
int getAge(){
return this->age;
}
};
//const int Person::read = 5;
int main(){
Person per(10);
//不能被修改
// per.read = 20;
cout<<per.read<<endl;
return 0;
}