java学习--day10 (继承)

文章目录

      • day9作业
      • 今天的内容
      • 1.继承
        • 1.1.生活中的继承
        • 1.2.Java中继承
        • 1.3关于父类子类的内存分析
        • 1.4重写【重点】
        • 1.5重载【overload】

day9作业

1.构造代码块和构造方法的区别
{
	代码块
}
public 类名 () {

}
都是实例化一个对象的时候执行的
只不过构造代码块先于构造方法执行的
2.局部变量和成员变量区别
	局部变量写在方法中,只能在方法体中使用,出了这个方法就不能再使用了
	成员变量写在类中,整个类都可以使用的。
3.声明类的语法格式
	class 类名 {
		属性
		构造方法
		方法
	}
4.一个类中属性的意义是啥
	用来描述一个类的特征的,可以通过对象对这个特征进行赋值的
5.构造方法的语法格式
public 类名 () {

}
public 类名 (参数) {

}
6.逻辑运算符的简单介绍
	
7.封装
 	1.对成员变量加修饰符 private
 	2.一定要写setter和getter方法进行赋值和取值即可
 8.this关键字
 	1.this关键字可以调用成员属性和方法
 	2.this还可以调用构造方法
 9.一个类对象作为方法的参数
 10.多类合作
 

今天的内容

1.继承

2.继承的内存分析

3.重写和重载

1.继承

Java 有三大特性: 封装 继承 多态

1.1.生活中的继承

子承父业

龙生龙 凤生凤

老鼠生来会打洞

你长得真像你父亲

1.2.Java中继承

继承是类和类之间的关系

继承至少得两个类:

语法格式:

class B  extends A {

}

其中 B是一个类,A是一个类

B类继承了A类。 B叫A的子类。A是B的父类(超类,基类)

入门案例:

package com.qfedu.b_extends;

class Father {
	String name;
	int age;
	//行为
	public void eat () {
		System.out.println("吃大盘鸡拌面");
	}
}
//使用了extends以后  Son 类就继承了Father这个类
//就意味着我Son类可以使用Father类下面某些属性和某些方法
class Son extends Father{
	
}

public class Demo1 {
	public static void main(String[] args) {
		Son son = new Son();
		//发现继承以后,可以使用父类一些属性
		son.name = "小骚磊";
		son.age = 1;
		System.out.println(son.name);
		System.out.println(son.age);
		son.eat();
		
	}

}

案例:

Animal 类 父类

Dog类 子类

Cat类 子类

继承的意思,就是将父类的属性和方法拿到子类中去使用

1.成员变量(属性)

​ 公开的和默认的属性,子类可以继承使用的

​ 私有的成员变量,子类无法使用的

2.成员方法

​ 公开的和默认的成员方法,子类可以继承使用

​ 私有的成员方法,子类无法使用的

总结:凡是私有的 无法继承。

3.构造方法

​ 先执行父类的构造,再执行子类的构造方法

​ 如果父类中有有参构造,但是没有无参构造。子类会报错

​ 关于构造方法:父类与子类的构造方法的形式保持一致。
​ 父类中有无参构造。子类也有无参构造。父类中没有无参构造,子类也没有无参构造方法

package com.qfedu.c_extends;

class Father {
	//只要是公开的或者默认的属性,子类可以使用的
	public String name;//公开的一个属性
	int age;//就是默认的属性
	private int id;//private修饰的 子类不能使用
	
	public Father () {
		System.out.println("父类的构造方法");
	}
	public Father (String name) {
		this.name = name;
	}
	//eat方法 使用public修饰的  子类可以使用
	public void eat () {
		System.out.println("吃窝窝头");
	}
	//默认的方法  子类是可以使用的
	void work () {
		System.out.println("开拖拉机耕地");
	}
	//  使用private修饰的方法就是私有化的方法,子类能调用吗?不能
	private void smoking () {
		System.out.println("抽旱烟");
	}	
}
class Son extends Father {

	
	//在子类写有参构造即可
	
	
}
public class Demo1 {
	public static void main(String[] args) {
		Son son = new Son();
		//验证name  age在子类中可以使用的
		son.name = "狗蛋";
		son.age = 12;
		//son.id = 12;
		son.eat();//可以使用父类的公开的方法
		son.work();
		//不可以使用父类私有化的方法
		//.son.smoking();
		
	}

}

刚才在写代码的时候,发现私有成员变量子类不能用。还有私有化的方法子类不能调用。咋办?

package com.qfedu.c_extends;

class Father1 {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	private void smoking () {
		System.out.println("抽旱烟");
	}
	public void test () {
		smoking();
	}
	
	
}
class Son1 extends Father1 {
	
}
public class Demo2 {
	public static void main(String[] args) {
		Son1 son1 = new Son1();
		//咋办? 可以使用setter和getter方法
		//son1.name = "";
		son1.setName("狗蛋");
		System.out.println(son1.getName());
		son1.test();
	}

}

练习的案例:

​ Animal 类:

​ 属性 : name, age ,sex 私有化的

​ 方法: 吃 运动

​ 子类:Panda

​ 使用Panda继承Animal 并可以使用Animal下面的所有属性和方法,对属性进行赋值

​ 方法调用

package com.qfedu.c_extends;

class Animal {
	private String name;
	private int age;
	private char sex;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	//方法
	public void eat () {
		System.out.println("吃饭");
	}
	public void sport () {
		System.out.println("运动");
	}
	
}
class Panda extends Animal {
	
}
//继承有啥好处呢?代码可以重复利用
class Cat extends Animal {
	
}
class Dog extends Animal {
	
}
public class Demo3 {
	public static void main(String[] args) {
		Panda panda = new Panda();
		panda.setName("熊大");
		panda.setAge(9);
		panda.setSex('公');
		panda.eat();
		panda.sport();
	}

}

继承:

​ Java中的继承都是单继承。只能有一个父类

​ Java中可以多重继承

package com.qfedu.c_extends;

class A {
	
}
class B extends A{
	
}
class C extends B {
	
}
public class Demo4 {
	public static void main(String[] args) {
		
	}

}

总结:

1.至少两个类,使用关键字extends
2.子类是否能使用父类的成员变量和成员方法
	子类不能使用父类私有化的所有的东西
	
1.3关于父类子类的内存分析

java学习--day10 (继承)_第1张图片

1.4重写【重点】

Override

重写目的:子类可以继承父类的非私有化的方法,但是有的 时候父类的需求满足不了子类的需求了,这个时候需要重写父类非私有的方法

​ 重写要求:

1.必须有继承关系
2.父类的方法必须是非私有化的
3.在子类中重写父类的方法,这个方法除了方法体不一样其他都一样的。
4.必须再子类中去重写
package com.qfedu.d_override;

class Father {
	public void eat () {
		System.out.println("吃粗粮。。。。。。");
	}
	public void driver () {
		System.out.println("开拖拉机。。。。。");
	}
}
//当父类不能满足子类的需求的话可以在子类中重写父类的方法
class Son extends Father {
		//重写的时候在子类中 只需要打上方法的名字一敲回车即可
		//重写的方法  和父类 的 返回值  参数  方法名字 一模一样,但是方法体不一样的
		@Override//是重写的严格限定,只要有这个,就证明咱们下面的这个方法
		//就是重写的方法,告知程序员 此时eat方法是重写的不是自己独有的
	public void eat() {
		System.out.println("吃白面馒头......");
	}
	@Override
	public void driver() {
		System.out.println("开小汽车");
	}
	
}
public class Demo1 {
	public static void main(String[] args) {
		Son son = new Son();
		son.eat();
		son.driver();
		//重写的话,是不影响父类的方法的
		Father father = new Father();
		father.eat();
		father.driver();
	}

}

案例:

父类:
	交通工具:
		方法 run();
两个子类:
	飞机:
		方法 run()
	高铁:
		方法 run()
	公交车:
		方法 run()
package com.qfedu.d_override;

class Transportation {
	public void run () {
		System.out.println("可以跑......");
	}
	
}
class Fly extends Transportation {
	//是继承 我就u可以重写父类下面的方法了
	@Override//开启重写的严格的限制,告知编译器,下面的方法必须是重写的
	public void run () {
		System.out.println("飞机跑的很快大概500km/h");
	}
	
}
class Train extends Transportation {
	@Override
	public void run() {
		System.out.println("在铁轨上跑的300km/h");
	}
}
class Bus extends Transportation {
	@Override
	public void run() {
		System.out.println("在公路上跑的60km/h");
	}
}
public class Demo2 {
	public static void main(String[] args) {
		Train train = new Train();
		train.run();
	}
	

}

1.5重载【overload】

在Java中同一个类中可以有很多个方法。方法名字一样。但是参数类型不一样。这种叫重载

总结:

1.方法的重载必须在同一个类中
2.方法名字必须一致
3.方法的参数类型必须不一样
4.方法的返回值可以不一样
5.无参构造和有参构造 也是一种重载

面试题: 重写和重载的区别

package com.qfedu.d_override;

class Person {
	//在一个类中,方法法名字一样,但是参数一定不一样。这叫方法的重载
	//返回值可以不一样
	public void test () {
		System.out.println("test");
	}
	public void test (String name) {
		System.out.println(name);
	}
	public void test (int i) {
		System.out.println(i);
	}
	void test (double d1) {
		
	}
	public String test(String str1, String str2) {
		return str1 + str2;
	}
}
public class Demo3 {
	public static void main(String[] args) {
		
	}

}

你可能感兴趣的:(Java基础,java)