Java的三大特征:封装 继承 多态
Java继承:继承只能是单继承,只能有一个父类,但是可以多重继承。
class A{
}
class B extends A{
}
class C extends B{
}这是多重继承
在中国而言继承的关系就是:儿子去继承父类的所有东西。
在代码中继承的语法格式:class B extends A{
可以继承父类所相关的属性和方法。
}
使用关键字:extends关键字
class B extends A{
}
B继承了A B是A的儿子 A是B的父亲 B可以继承父类A所有的东西
class Person{
String name;
int age;
double weight;
//父类下面的方法
public void eat(){
System.out.println("在吃窝窝饭");
}
}
class Man extends Person{
}
public class Demo1{
public static void main(String[] args){
Man man = new Man();
man.name="鲜明";
man.age=29;
man.weight=12.2;
System.out.println(man.name);
System.out.println(man.age);
System.out.peintln(man.weight);
//使用对象.调用方法
man.eat();
}
}
继承注意事项:
成员变量:公开的和默认的成员变量,则子类可以继承父类的。
私有化的成员变量则子类不可以继承。
成员方法:公开的和默认的成员方法,则子类可以继承父类。
私有化的成员方法,则子类不可以继承。
构造方法:如果父类中有有参构造,没有无参构造那么子类会报错。
如果父类中没有无参构造,那么子类也是不能有无参构造的。
先执行父类的构造方法,在执行子类的构造方法。
父类的构造方法必须和子类的构造方法保持一致。
在开发中遇到了私有化的变量和属性如何解决?
使用Set和Get进行赋值和取值。
class Animal{
private int age;//私有化的变量
private String name;
private double weight;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
public void setWeight(double weight){
this.weight=weight;
}
public double getWeight(){
return weight;
}
public void sleep(){
System.out.println("动物在睡觉");
}
public void eat(){
System.out.println("动物在吃饭");
}
}
class Dog extends Animal{//Dog继承了变量Animal
}
public class Demo2{
public static void main(String[] args){
Dog dog = new Dog();
dog.setAge(22);
dog.setName("小明");
dog.setWeight(100.0);
System.out.println(dog.getName());
System.out.println(dog.getAge());
System.out.println(dog.getWeight());
}
}
构造方法
分为无参构造和有参构造
类中有无参构造和有参构造,当new对象的时候会自动匹配构造方法
class Dog {
public String name;//公开的成员变量
int age;//默认的成员变量
public void eat(){
System.out.println("在吃饭");//公开的成员方法
}
void sleep(){
System.out.println("默认的成员方法");
}
public Dog(){//构造方法是用来初始化类对象的,可以对属性进行的赋值,对象的创建就是依据构造方法来创建的。
}
public Dog(String name,int age){
this.name=name;
this.age=age;
}
}
class Ca extends Dog{
//小爱对着String name 22对照着的int age
public Ca(String name,int age){//子类中的有参构造
this.name=name;
this.age=age;
}
}
public class Demo3{
public static void main(){
Ca ca = new Ca("小爱",22);//当new ca的时候会对照着子类中的有参构造
ca.name="小猫";
ca.age=22;
//结果为小猫 22 因为上面的赋值的早所以会被覆盖掉
System.out.println(ca.name);
System.out.println(ca.age);
}
}
继承的案例
Animal 类:
属性 : name, age ,sex 私有化的
方法: 吃 运动
子类:Panda
使用Panda继承Animal 并可以使用Animal下面的所有属性和方法,对属性进行赋值
方法调用
class Animal{
String name;
int age;
char sex;
public void eat(){
System.out.println("再吃");
}
public void sleep(){
System.out.println("在运动");
}
}
class Panda extends Animal{
}
public class Demo2{
public static void eat(){
panda.name="小动物";
panda.age=20;
panda.sex='男';
System.out.println(panda.name);
System.out.println(panda.age);
System.out.println(panda.sex);
//调用方法 对象.方法的名字
panda.eat();
panda.sleep();
}
}
override重写
重写的目的:子类可以继承父类的属性和方法,但是父类方法的需求已经满足不了子类了,则需要在子类中重写方法。
override重写的用法
class Person{
String name;
int age;
double weight;
public void eat(){
System.out.println("在吃窝窝头");
}
public void sleep(){
System.out.println("在睡觉");
}
}
class Man extends Person{
//父类的需求已经满足不了子类了,则需要重写
public void eat(){
System.out.println("再吃烤肠");
}
public void sleep(){
System.out.println("在沙发上舒服的休息着");
}
}
public class Demo3{
public static void main(String [] args){
Man man = new Man();
//重写了父类的方法
man.eat();
man.sleep();
man.name="洗脑";
man.age=22;
man.weight=100.0;
System.out.println(man.age);
System.out.println(man.name);
System.out.println(man.weight);
}
}
overload重载
重载的目的:在同一个类中,方法的名字可以一样但是参数一定不一样,返回值可以一样也可以不一样。
class Animal{
public void eat() {
System.out.println("再吃饭");
}
public void eat(String name) {
System.out.println(name);
}
public void eat(int i) {
System.out.println(i);
}
public void eat(double d1) {
System.out.println(d1);
}
}
public class Test6{
public static void main(String[] args) {
Animal animal = new Animal();
animal.eat();
animal.eat("小明");
animal.eat(22);
animal.eat(100.0);
}
}