-
继承
* 子承父业
*
* 为什么要继承:
* 为了提高代码的服用性
* 如何使用继承:
* 子类 extends 父类 使用继承
*
* 注意:
* 1.子类继承父类,可以使用父类中所有的成员
* 2.在java中只支持单继承,一个java类可以被多个子类继承的,一个java类只能继承一个父类,但是支持多实现
*
* 单继承的缺点:
* 不便于后期维护
* 单继承的优点:
* 使用简单(加入继承了多个父类,中有限相同的成员,不变化于判断和使用)
public class ExtendsDemo04 {
public static void main(String[] args) {
Student s = new Student();
s.name = "马云";
s.age = 19;
s.info();
s.study();
s.sleep();
Teacher t = new Teacher();
t.name = "因为";
t.age = 18;
t.info();
t.teach();
t.sleep();
}
}
// 父类
class Person1 {
// 名字
String name;
// 年龄
int age;
// 休息
public void sleep() {
System.out.println("休息...");
}
}
// 教师类
class Teacher extends Person1 {
// 专业
String subject;
// 授课
public void teach() {
System.out.println(name + "在传授知识...");
}
// 介绍
public void info() {
System.out.println(name + "-->" + age + "--->" + subject);
}
}
// 学生类
class Student extends Person1 {
// 家乡
String hometown;
// 学习
public void study() {
System.out.println("学java....");
}
// 介绍
public void info() {
System.out.println(name + "-->" + age + "--->" + hometown);
}
}
-
权限修饰符
* 权限修饰符 : 访问对象中成员的权限范围
* 本类 同包类 不同包子类 全部 --从小到大的访问范围
* private Y
* default Y Y
* protected Y Y Y
* public Y Y Y Y
*
* 注意:
* 1所有的被private修饰的成员都不能再外部访问,也不能被子类继承
* 2以上所有的权限修饰符都只能修饰成员(方法和成员变量)
* 3只能用public,default修饰类,default要省略
*
* 父类:基类
* 子类:派生类
*
* 开闭原则:
* 对修改关闭,对扩展开放
public class ModifierDemo05 {
public int a=5;
protected int b=4;
int c=3;
public static void main(String[] args) {
Sicong s=new Sicong();
s.test();
//s.lover=""; 私有不可见
}
}
class Janlin{
//钱
public long money=2000000000;
//小蜜
private String lover="西施";
//颜值
String face="帅";
//height
protected double height=180;
//私房钱
public void sifang(){
System.out.println("每个月给"+lover+"1000000零花钱...");
}
}
class Sicong extends Janlin{
//事业
public void shiye(){
System.out.println("熊猫TV...");
}
public void test(){
System.out.println("public:"+money);
//System.out.println("private:"+lover);
System.out.println("default:"+face);
System.out.println("protected:"+height);
ModifierDemo05 m=new ModifierDemo05();
System.out.println(m.a);
System.out.println(m.b);
System.out.println(m.c);
}
}
-
重写
* 重写(override) --- 重载(overload)
* 重载:同一个类中,不同的方法之间有相同的方法名,不同的参数类表
* 满足重写的条件:
* 1.不同的类
* 2.继承
* 3.相同的方法签名(方法名+参数列表)
*
* 子类中重写父类中的方法,调用的时候,会对父类的方法进行屏蔽
* 方法的重写和重载都是针对于方法而言的
*
* 判断重写的依据:
* 1.左边有一个向上的三角形
* 2.在方法的上面添加一个注解@Override,用来测试是否重写的方法
*
* = : 方法签名
* <= : 方法的返回值类型 基本数据类型必须相同 引用数据类型:子类<=父类
* >= : 权限修饰符 子类>=父类
*
* 不能被重写的方法:
* 1.被private修饰的方法不能被重写
* 2.被final修饰的方法不能被重写
* 3.被static修饰的方法不能被重写
*
* 注意:如果子父类中有方法签名相同方法,父类中的同名被static修饰了,子类中的方法也要添加static
public class OverrideDemo06 {
public static void main(String[] args) {
Sicong1 s = new Sicong1();
s.speak();
s.test();
System.out.println(s.name);
Jianlin j = new Jianlin();
j.speak();
j.test();
}
}
// 父类
class Jianlin {
String name = "Jianlin";
public void speak() {
System.out.println("先定一个小目标,赚他个一个亿...");
}
static Jianlin test() {
System.out.println("父类");
return new Jianlin();
}
}
// 子类
class Sicong1 extends Jianlin {
String name = "Sicong";
public void speak(int a) {
System.out.println("我交朋友从来不在乎他有没有钱,反正都没我有钱...");
}
public static Sicong1 test() {
System.out.println("子类");
return new Sicong1();
}
}
-
super关键字
* super()
* 调用父类的构造器,会在子类构造器的首行,隐式的调用父类的空构造
* 显示父类的其他构造器,super(参数列表)
* 注意:this和super在调用构造器的时候不能同时存在
* super.
* 指代父类对象,区分父类子类中同名成员
*
* super和this都不能使用在静态的内容中
* 先父类后子类
* 在没有显示调用父类构造器的时候,保证父类中有空构造
-
final关键字
* final 关键字
* 被final修饰变量为常量----不能改变
* 被final修饰的方法不能被重写
* 被final修饰的类不能被继承
-
Javabean
* private关键字 私有成员修饰符 ,不能修饰成员变量
* 把属性私有化 ,对外提供公共的访问方式,setter和getter
*
* 提高代码复用性,安全性,便于后期维护
*
* private是辅助的一种体现
*
* Javabean编码规则:
* 必须声明public class
* 至少存在一个无参构造方法
* 所有属性必须封装
* 为封装属性提供公共的访问方式
public class Person {
String name;
private int age;
public Person() {
// TODO Auto-generated constructor stub
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void eat() {
System.out.println(name + "--->" + age + "--->" + "eat...");
}
}
class PersonTest {
public static void main(String[] args) {
Person p = new Person();
p.name = "李四";
p.setAge(18);
p.eat();
}
}