面向对象四大特性
抽象:将现实事物或问题抽象成大脑中的概念模型
继承:一个类可以从一个现有的类当中派生出来，派生出来的类称为该类的子类，原有的类称为父类（基类，超类）
子类会拥有父类当中所有的属性和方法，除了：
①私有成员
②构造器
在Java中只支持单继承,一个子类只能有一个直接父类，一个父类可以有任意多个子类
继承的语法
public class A extends(拓展) B{}
继承带来的优点：
是一种代码重用的重要手段，也是实现"开闭原则"的基础，同时子类还可以添加自己独有的属性和方法，来拓展父类功能
开闭原则：对拓展开放，对修改关闭
public class Employee {
String name;// 名字
int id;// 工号
public void code() {
System.out.println(name+"在工作");
}
}
public class Manager extends Employee{
double money;
public void rest() {
System.out.println(name+"在休息");
}
}
public class Test {
public static void main(String[] args) {
Manager m = new Manager();
m.name = "李磊";
m.code();
m.rest();
Employee e = new Employee();
e.code();
Employee e1 = new Manager();
}
}
子类实例化的过程（创建一个子类对象时，发生了什么）
创建子类对象时，子类构造器会默认调用父类的无参构造器先创建父类对象，之后再创建子类对象
若父类没有无参构造器，子类构造器就必须使用super显式（写代码）调用父类的有参构造器，否则编译出错
super
①super(args)调用父类其他构造器，只能用在子类构造器，第一行，只能用一次
②super.属性名，super.方法名
方法的重写
public class FatherDemo1 {
int num = 100;
public void study() {
System.out.println("父类在努力学习");
}
}
public class SonDemo1 extends FatherDemo1{
int num = 20;// 注意属性不存在重写
String name = "leo";
public void test() {
System.out.println("test方法");
}
@Override
public void study() {
System.out.println(num);
System.out.println("子类在玩，不咋学习");
}
}
public class Test1 {
public Object getNum() {
return "String";
}
public static void main(String[] args) {
// FatherDemo1 sd = new FatherDemo1();
// SonDemo1 sd1 = new SonDemo1();
// sd1.name = "张三";
// sd1.num = 1;
// sd1.test();
// sd1.study();
// sd.study();// 父类在努力学习 子类在玩，不咋学习
// System.out.println(sd.num);
// 上溯造型（向上转型） ： 父类引用指向子类对象
// 父类引用不能访问子类拓展的属性和方法
// 调用的方法取决于对象类型，不取决于引用类型
FatherDemo1 sd = new SonDemo1();
sd.study();
System.out.println(sd.num);
// 下溯造型（向下转型）：子类引用指向父类对象，只有上溯过的才能下溯
SonDemo1 sd1 = (SonDemo1)sd;
FatherDemo1 sd2 = sd1;
FatherDemo1 sd3 = new SonDemo2();
FatherDemo1 sd4 = sd3;
// 判断一个引用指向哪一个类
if(sd4 instanceof SonDemo1) {
System.out.println("SonDemo1");
}
if(sd4 instanceof SonDemo2) {
System.out.println("SonDemo2");
}
// Test1 t = new Test1();
// String str = (String)t.getNum();
// System.out.println(str.length());
}
}
封装:将功能组织到方法中，将属性和方法组织到类中都是封装
访问权限修饰符
JavaBean实体类
public class Demo5 {
public static void main(String[] args) {
// Java面相对象特性：继承，封装，多态，抽象
// 抽象（程序员将现实实物抽象为脑中概念模型）
// 封装 ：将一套功能组织成一个方法，将一套方法加一套属性组织到一个类，将一套类组织到一个包中
// 访问权限修饰符
/*
* public : 公有，工程中可见
* 能修饰类，方法，属性（全局变量）
* protected : 受保护的,当前包可见，跨包的“亲戚(子类)”可见，“非亲戚（非子类）”不可见
* 能修饰方法和属性
* 【friendly,default】:默认的，跨包不可见
* 能修饰类，方法，属性（全局变量）
* private : 私有的，只有当前类可见
* 能修饰方法和属性
*/
// JavaBean(实体类) :
// 1.有无参构造器（必要）
// 2.属性全部私有
// 3.有公有的get（获取）和set（修改）方法
}
}
public class Student {
private int num = 10;
private int age = 20;
private String name;
public void test() {
System.out.println("测试方法");
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
多态:（一种事物的不用形态，对同一消息做出的不同响应）是一种编程策略
条件：
①要有泛化（继承，实现）关系；
②要有上溯造型（父类引用指向子类对象）；
③要有方法的重写
优点：解耦合（拓展性强，易维护）
public class Customer {
int id;
String name;
public void buy(TrainStation ts) {}
}
public class Student extends Customer{
public Student() {}
public Student(int id, String name) {
super();
this.id = id;
this.name = name;
}
@Override
public void buy(TrainStation ts) {
System.out.println(name+"是一个学员，打五折，收费"+ts.price*0.5);
}
}
public class Criminal extends Customer{
public Criminal() {}
public Criminal(int id, String name) {
super();
this.id = id;
this.name = name;
}
@Override
public void buy(TrainStation ts) {
System.out.println(name+"是一个罪犯，打骨折");
}
}
public class Teacher extends Customer{
public Teacher() {}
public Teacher(int id, String name) {
super();
this.id = id;
this.name = name;
}
@Override
public void buy(TrainStation ts) {
System.out.println(name+"是一个讲师，打八折，收费"+ts.price*0.8);
}
}
public class TrainStation {
int price = 100;
public void saleTicket(Customer c) {
TrainStation ts1 = this;
c.buy(ts1);
}
}
public class Test {
public static void main(String[] args) {
Customer s = new Student(1001, "小翟");
Customer t = new Teacher(9527, "大翟");
Customer c = new Criminal(1011011, "老翟");
Customer e = new Employee(1, "老翟1111");
TrainStation ts = new TrainStation();
ts.saleTicket(s);
ts.saleTicket(t);
ts.saleTicket(c);
ts.saleTicket(e);
}
}
在Java中多态有哪些体现
重载--编译时多态
重写--运行时多态
接口
public interface News {
// 发布新闻
void releaseNews();
}
/**
* 体育板块
* @author Administrator
*/
public class Sports implements News{
@Override
public void releaseNews() {
System.out.println("发布了一条体育新闻");
}
}
/**
* 娱乐板块
* @author Administrator
*/
public class Entertainment implements News{
public void releaseNews() {
System.out.println("发布了一条娱乐新闻");
}
}
/**
* 政治板块
* @author Administrator
*/
public class Polity implements News{
@Override
public void releaseNews() {
System.out.println("发布了一条政治新闻");
}
}
public class TestDemo1 {
public static void main(String[] args) {
while(true) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入要发布的新闻类型");
System.out.println("1--------体育新闻");
System.out.println("2--------政治新闻");
System.out.println("3--------娱乐新闻");
System.out.println("4----------退出");
int num = scan.nextInt();
// 上溯
News n = null;
if(num < 1 || num > 4) {
System.out.println("无此选项");
}else {
switch(num) {
case 1:
n = new Sports();
break;
case 2:
n = new Polity();
break;
case 3:
n = new Entertainment();
break;
case 4:
System.out.println("再见");
return;
}
n.releaseNews();
}
}
}
}
抽象类abstract
public static void main(String[] args) {
/*
* final
* 能修饰类，方法，属性（常量）
* final类不能被继承
* final方法不能被子类重写
* final属性常量，不能改变
*
* abstract抽象
* 能修饰
* 类 ：不能实例化（不能创建对象，但是有构造器），它的作用就是做父类
* 方法:抽象方法，没有方法体,如果一个类中有抽象方法，这个类必须是抽象类
* 抽象类中可以有非抽象方法
* 如果一个类继承了一个抽象类，就必须实现父类所有抽象方法，除非这个子类也是抽象类
*/
}
网友评论