一、
1、
package com.wanxi.school;
public class SchoolPeople {
private String name;
private int age;
public SchoolPeople() {
}
public SchoolPeople(String name, int age) {
this.name = name;
this.age = age;
}
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 void work() {
System.out.println("各司其职");
}
@Override
public String toString() {
final StringBuffer sb = new StringBuffer("SchoolPeople{");
sb.append("name='").append(name).append('\'');
sb.append(", age=").append(age);
sb.append('}');
return sb.toString();
}
}
2、
package com.wanxi.school;
public class Student extends SchoolPeople{
public Student() {
}
public Student(String name, int age) {
super(name, age);
}
@Override
public void work() {
System.out.println("好好学习");
}
}
3、
package com.wanxi.school;
public class Teacher extends SchoolPeople{
public Teacher(String name, int age) {
super(name, age);
}
public Teacher() {
}
@Override
public void work() {
System.out.println("认真教书");
}
}
4、
package com.wanxi.school;
public class SchoolTest {
public static void main(String[] args) {
SchoolPeople people1 = new Student("王海运", 21);
SchoolPeople people2 = new Teacher("陈明", 28);
System.out.println(people1);
people1.work();
System.out.println(people2);
people2.work();
}
}二、
1、
package com.wanxi.worker;
public class Worker {
private int WorkerNumber;
private String name;
private int salary;
public Worker() {
}
public Worker(int workerNumber, String name, int salary) {
WorkerNumber = workerNumber;
this.name = name;
this.salary = salary;
}
public int getWorkerNumber() {
return WorkerNumber;
}
public void setWorkerNumber(int workerNumber) {
WorkerNumber = workerNumber;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public void work() {
System.out.println("自己找事情做");
}
@Override
public String toString() {
final StringBuffer sb = new StringBuffer("Worker{");
sb.append("WorkerNumber=").append(WorkerNumber);
sb.append(", name='").append(name).append('\'');
sb.append(", salary=").append(salary);
sb.append('}');
return sb.toString();
}
}
2、
package com.wanxi.worker;
public class Coder extends Worker {
public Coder() {
}
public Coder(int workerNumber, String name, int salary) {
super(workerNumber, name, salary);
}
@Override
public void work() {
System.out.println("给领导打工");
}
}
3、
package com.wanxi.worker;
public class Manger extends Worker {
private int bonus;
public Manger() {
}
public int getBonus() {
return bonus;
}
public void setBonus(int bonus) {
this.bonus = bonus;
}
public Manger(int workerNumber, String name, int salary, int bonus) {
super(workerNumber, name, salary);
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("管理别人");
}
@Override
public String toString() {
return "Worker{WorkerNumber=" + getWorkerNumber() + ",name= '" + getName() + '\'' + " , salary=" + getSalary() + " , bonus=" + getBonus() + "}";
}
}
4、
package com.wanxi.worker;
public class WorkerTest {
public static void main(String[] args) {
Worker worker1 = new Coder(20130050, "陈明", 15000);
Worker worker2 = new Manger(2010055, "王海云", 18200, 5000);
System.out.println(worker1);
worker1.work();
System.out.println(worker2);
worker2.work();
}
}
三、
1、
package com.wanxi.school;
public class Fu {
private void show1() {
System.out.println("private");
}
void show2() {
System.out.println("默认");
}
protected void show3() {
System.out.println("protected");
}
public void show4() {
System.out.println("public");
}
// public static void main(String[] args) {
// //创建Fu的对象，测试看有哪些方法可以使用
// Fu f = new Fu();
// f.show1();
// f.show2();
// f.show3();
// f.show4();
// }
}
//private,只能是同一个类中，有权限
//没写权限修饰，就是缺省，只能是 同一个包里的子类 和同一个包里的非子类 有权限。
//protected，只能是 同一个包里的子类 和同一个包里的非子类 以及 不在用一个包下的子类 有权限。
//public,没有限制2、
package com.wanxi.school;
public class Demo {
public static void main(String[] args) {
//创建Fu的对象，测试看有哪些方法可以使用
Fu f = new Fu();
// f.show1();
f.show2();
f.show3();
f.show4();
}
}
3、
package com.wanxi.school;
public class Zi extends Fu {
public static void main(String[] args) {
//创建Zi的对象，测试看有哪些方法可以使用
Zi z = new Zi();
// z.show1();
z.show2();
z.show3();
z.show4();
}
}
4、
package com.wanxi.worker;
import com.wanxi.school.Fu;
public class Zi extends Fu {
public static void main(String[] args) {
//创建Zi的对象，测试看有哪些方法可以使用
Zi z = new Zi();
z.show3();
z.show4();
}
}
1、继承
继承是面向对象三大特征之一。(封装，继承，多态)可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。
格式：public class 子类名 extends 父类名 { }
范例：
public class Zi
extends
Fu { }
Fu
：是父类，也被称为基类、超类
Zi
：是子类，也被称为派生类
继承中子类的特点：
子类可以有父类的内容
子类还可以有自己特有的内容
继承好处
提高了代码的
复用性
(
多个类相同的成员可以放到同一个类中
)
提高了代码的
维护性
(
如果方法的代码需要修改，修改一处即可
)
继承弊端
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
在子类方法中访问一个变量
子类局部范围找
子类成员范围找
父类成员范围找
如果都没有就报错
(
不考虑父亲的父亲
…)
super关键字的用法和 this 关键字的用法相似
this
：代表
调用该方法的对象
(
一般我们是在当前类中使用
this
，所以我们常说
this
代表
本类对象的引用
)
super
：代表父类存储空间的标识
(
可以理解为父类对象引用
)
子类中所有的构造方法默认都会访问父类中无参的构造方法
子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化
每一个子类构造方法的第一条语句默认都是：super()
如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？
① 通过使用
super
关键字去显示的调用父类的带参构造方法
② 在父类中自己提供一个无参构造方法
推荐：自己给出无参构造方法
通过子类对象访问一个方法
子类成员范围找
父类成员范围找
如果都没有就报错
(
不考虑父亲的父亲
…)
方法重写概述
子类中出现了和父类中一模一样的方法声明
方法重写的应用
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，
又定义了子类特有的内容
@Override
是一个注解
(
注解后面会学习到
)
可以帮助我们检查重写方法的方法声明的正确性
2、修饰符
//private,只能是同一个类中，有权限 //没写权限修饰，就是缺省，只能是 同一个包里的子类 和同一个包里的非子类 有权限。 //protected，只能是 同一个包里的子类 和同一个包里的非子类 以及 不在用一个包下的子类 有权限。 //public,没有限制。
final 关键字是最终的意思，可以修饰成员方法，成员变量，类
final 修饰的特点
修饰方法：表明该方法是最终方法，
不能被重写
修饰变量：表明该变量是常量，
不能再次被赋值
修饰类：表明该类是最终类，
不能被继承
变量是基本类型：
final
修饰指的是基本类型的
数据值
不能发生改变
变量是引用类型：
final
修饰指的是引用类型的
地址值
不能发生改变，但是地址里面的内容是可以发生改变的
static 关键字是静态的意思，可以修饰成员方法，成员变量
static 修饰的特点
① 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
② 可以通过类名调用，当然，也可以通过对象名调用，
推荐使用类名调用
非静态的成员方法
能访问静态的成员变量
能访问非静态的成员变量
能访问静态的成员方法
能访问非静态的成员方法
静态的成员方法
能访问静态的成员变量
能访问静态的成员方法
总结成一句话就是：静态成员方法只能访问静态成员
971
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
