Java9面向对象
面向对象编程（Object-Oriented Programming，OOP）
面向对象编程的本质是：以类的方式组织代码，以对象的组织（封装）数据
-
抽象
-
三大特性：
-
封装
-
继承
-
多态
-
从认识论角度考虑是先有对象后有类
-
对象：是具体的事物
-
类：是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象
-
类：是对象的模板
回顾方法及加深
-
方法的定义
-
修饰符
-
返回类型
-
break：跳出switch，结束循环和return的区别
-
方法名：注意规范 见名知意
-
参数列表：（参数类型，参数名）...
-
异常抛出：疑问
//Demo01 类
public class Demo01 {
//main 方法
public static void main(String[] args) {
}
/*
修饰符 返回值类型 方法名（。。。）{
//方法体
return 返回值;
}
*/
//return结束方法，返回一个结果
public String sayHello(){
return "Hello World";
}
public void print(){
return;
}
public int max(int a,int b){
return a>b ? a : b; //三元运算符
}
//抛出异常：如数组下标越界：Arrayindexoutofbounds
public void readFile(String file) throws IOException{
}
} -
-
方法的调用
-
静态方法 static
-
非静态方法
public class Demo02 {
public static void main(String[] args) {
//静态方法直接调用即可
Student.see();
//非静态方法须先实例化类
//实例化类 new
//对象类型 对象名 = 对象值；
Student student = new Student();
student.say();
}
//和类一起加载的
public static void a(){
new Demo02().b();
}
//类实例化之后才存在
public void b(){
a();
}
}-
形参与实参
//Demo01 类
public class Demo03 {
public static void main(String[] args) {
//实际参数和形式参数要对应
new Demo03().add(1,2);
}
public int add(int a,int b){
return a+b;
}
}-
值传递和引用传递
//值传递
public class Demo04 {
public static void main(String[] args) {
int a = 1;
System.out.println(a); //1
Demo04.change(a);
System.out.println(a); //1
}
//返回值为空
public static void change(int a) {
a = 10;
return;
}
}-
this关键字
-
类与对象的关系
类是一种抽象的数据类型，是对某一类事物整体的描述/定义，但斌不能代表某一个具体的事物
-
动物、职务、手机、电脑。。。。。。
-
Person类、Pet类、Car类等，类都是用来描述/定义某一类具体事物应该具备的特点和行为
对象是抽象概念的具体实例
-
张三是人的一个具体实例，张三家里的旺财则是够的一个具体实例
-
能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念
创建与初始化对象
使用new关键字创建对象
使用new关键字创建时，除了分配内存空间外，还会给 创建好的对象 进行默认的初始化以及对类中构造器的调用
类中的构造器也被称为构造方法，是在进行创建对象时必要调用的
并且构造器有以下两个特点：
-
1.必须和类的名字相同
-
2.必须没有返回类型，也不能写void
构造器必须掌握
//学生类
public class Student {
//属性：字段
String name; //null
int age; //0
//方法
public void study(){
System.out.println(this.age+"岁的"+this.name+"在学习");
}
}
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类：抽象的，需要实例化
//类实例化后返回一个自己的对象
//student对象就是一个Student类的具体实例
Student xiaoming = new Student();
Student xh = new Student();
xiaoming.name ="小明";
xiaoming.age = 3;
System.out.println(xiaoming.name); //小明
System.out.println(xiaoming.age); //3
xiaoming.study(); //3岁的小明在学习
xh.name ="小红";
xh.age = 3;
System.out.println(xh.name); //小红
System.out.println(xh.age); //3
}
}
构造器：
//java --->class
public class Person {
//一个类即使不写任何东西，也会存在一个方法
String name;
//实例化初始值
//1.使用new关键字，本质是在调用构造器
public Person(){
}
//有参构造:一旦定义了有参构造，无参构造必须显示定义
public Person(String name){
this.name = name;
}
}
/*
构造器：
1.和类名相同
2.没有返回值
作用：
1.new本质是调用构造方法
2.初始化对象的值
注意点：
1.定义有参构造之后，如果想使用无参构造，则显示定义一个无参构造
Alt + Insert --> Constructor 快捷输出有参、无参构造
*/
public class Application {
public static void main(String[] args) {
//new 实例化一个对象
Person person = new Person("wang");
System.out.println(person.name); //wang
}
}
小结类与对象：
1.类与对象
-
类是一个模板：抽象
-
对象是一个实例：具体
2.方法
定义、调用
3.对应的引用
-
引用类型： 八大基本类型
-
对象是通过引用来操作的：栈--->堆
4.属性： 字段Field 成员变量
-
默认初始化：
-
数字： 0 0.0
-
char： u0000
-
boolean: false
-
引用： null
-
修饰符 属性类型 属性名 = 属性值
5.对象的创建和使用
-
必须使用new 关键字创造对象，构造器 Person wang = new Person()；
-
对象的属性 wang.name
-
-
对象的方法 wang.sleep();
6.类：
-
静态的属性 属性
-
动态的行为 方法
重要：封装、继承、多态
封装
该藏藏，该露露 ====>属性私有private，get/set
-
程序设计须追求“高内聚，低耦合”
-
高内聚：即类的内部数据操作细节自主完成，不允许外部干涉
-
低耦合：即仅暴露少量的方法给与外部使用
-
封装：即数据的隐藏
-
通常，应禁止直接访问一个对象中数据的实际表示，而是通过操作接口来访问，称为信息隐藏
//类
public class Student {
//属性私有
private String name;//名字
private int id;//学号
private char sex;//性别
private int age;//年龄，不会小于0岁，一般不会大于120岁
//提供一些可操作这个私有属性的方法
//提供一些public 的get、set方法
//get 获得这个属性
public String getName() {
return this.name;
}
//set 给这个数据设置值
public void setName(String name) {
this.name = name;
}
//Alt + Insert
public int getAge() {
return age;
}
public void setAge(int age) {
if (age<0 || age>120){
this.age = 3;
System.out.println("你是3岁小孩吧");
}else {
this.age = age;
}
}
}
/*
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.提高系统的可维护性
*/
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
//方法名，参数列表
s1.setName("黑铁");
System.out.println(s1.getName());
s1.setAge(999);//不合法
System.out.println(s1.getAge());
}
}
继承
继承的本质是对某一批类的抽象
extends的意思是“扩展”。子类是父类的扩展
JAVA中类只有单继承，没有多继承
即单个子类只能有一个父类，但一个父类可以有多个子类
继承是类和类之间的一种关系，除此之外，类与类之间还有依赖、组合、聚合等关系
继承关系的两个类，一个为子类（派生类），一个为父类（基类）
子类继承父类，使用关键字extends来表示
子类与父类之间，从意义上说应具有“is a”的关系
object类：
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
System.out.println(student.getMoney());
}
}
//Java中，所有的类，都直接或者间接继承Object类
//人： 父类，基类
public class Person /*extends Object*/{
//public 公共的
//protected 受保护的
//default 默认的
//private 私有的
protected int money = 10_0000_0000;
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public void say(){
System.out.println("说了一句话");
}
}
//学生 is 人： 子类，派生类
//子类继承父类，就会有父类的全部方法
public class Student extends Person{
//Ctrl + H 侧边栏类关系图
}
super -- this：
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.test("老铁");
student.test1();
}
}
public class Person /*extends Object*/ {
public Person() {
System.out.println("Person无参执行");
}
protected String name = "wang";
//私有的无法被继承
public void print() {
System.out.println("Person");
}
}
public class Student extends Person {
public Student() {
//隐藏代码 super(); 默认调用父类的无参构造
//调用父类的构造器，必须在子类构造器的第一行
System.out.println("Student无参执行");
}
private String name = "黑铁佣兵";
public void print() {
System.out.println("Student");
}
public void test1() {
print();//Student
this.print();//Student
super.print();//Person
}
public void test(String name) {
System.out.println(name);//老铁
System.out.println(this.name);//黑铁佣兵
System.out.println(super.name);//wang
}
}
super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或构造方法中
3.super 和 this 不能同时调用构造方法
对比 this：
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的引用
前提：
this：没有继承也可以使用
super：只有在继承条件下才可以使用
构造方法：
this(); 本类的构造
super(); 父类的构造
方法重写：重点 ==> 多态
public class Application {
//静态方法： 方法的调用只和左边->定义的数据类型有关
//非静态方法：重写
public static void main(String[] args) {
A a = new A();
a.test();//A=>test()
//父类的引用可以指向子类
B b = new A();//子类重写了父类的方法
b.test();//A=>test()
}
}
//继承
public class A extends B{
//Override 重写
@Override //注解：有功能的注释
public void test() {
System.out.println("A=>test()");
}
}
//重写：都是方法的重写，与属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}
重写：需要有继承关系，子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大但不能缩小； public>protected>default>private
4.抛出的异常：范围可以被缩小但不能扩大； ClassNotFoundException --> Exception(大)
重写：子类的方法和父类必须一致，方法体不同
为什么需要重写：
1.父类的功能，子类不一定需要，或者不一定满足
Alt + Insert：override;
多态
即同一方法可以根据发送的对象的不同而采用多种不同的行为方式
一个对象的事迹类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件
-
有继承关系
-
子类重写父类的方法
-
父类引用指向子类对象
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
//可以指向的引用类型不确定：父类的引用指向子类
//Student 能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
//Person 父类型，可以指向子类，但不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
s2.run();//子类重写父类方法，执行了子类的方法
s1.run();
((Student) s2).eat();
s1.eat();
}
}
public class Person {
public void run() {
System.out.println("run");
}
}
/*
多态注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常ClassCastException
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1 = new Son();
1.static 方法，属于类，不属于实例
2.final 常量;
3.private 方法;
*/
public class Student extends Person {
@Override
public void run() {
System.out.println("son");
}
public void eat() {
System.out.println("eat");
}
}
instanceof （类型转换）
引用类型，判断一个对象是什么类型
public class Application {
public static void main(String[] args) {
//Object > String
//Object > Person > Student
//Object > Person > Teacher
Object object = new Student();
//System.out.println(X instanceof Y);
//编译能不能通过取决于：X与Y之间有没有继承关系
//true与false取决于：X所指向的实际类型是否是Y的子类型
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false
System.out.println("==========================");
Person person = new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
//System.out.println(person instanceof String);//编译报错，person与String无继承关系
System.out.println("==========================");
Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);//编译报错，student与Teacher无继承关系
//System.out.println(student instanceof String);//编译报错，student与String无继承关系
}
}
类型转换：
public class Person {
public void run(){
System.out.println("run");
}
}
public class Student extends Person{
public void go(){
System.out.println("go");
}
}
父类转换为子类：
public class Application {
public static void main(String[] args) {
//类型之间的转换： 父 子
//高 低
Person obj = new Student();
//将obj这个对象转换为Student类型，就可以使用Student类型的方法
((Student)obj).go();
Student student = (Student) obj;
student.go();
}
}
子类转换为父类：
public class Application {
public static void main(String[] args) {
//子类转换为父类之后，可能丢失自己本身的一些方法
Student student1 = new Student();
student1.go();
Person person =student1;
}
}
static关键字
//static
public class Student {
private static int age; //静态的变量
private double score; //非静态的变量
public void run() {
go();//非静态方法可直接调用静态方法
}
public static void go() {
}
public static void main(String[] args) {
go();//静态变量或方法跟随类一起加载，可直接调用
Student s1 = new Student();
s1.run();//非静态变量或方法只能在实例化对象后才能调用
System.out.println(Student.age);
System.out.println(s1.age);
System.out.println(s1.score);
}
}
扩展：代码块
public class Person {
//2：赋予初始值
{
//代码块（匿名代码块）
System.out.println("匿名代码块");
}
//1：只执行一次
static {
//静态代码块
System.out.println("静态代码块");
}
//3
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 = new Person();
System.out.println("===========");
Person person2 = new Person();
}
/*
输出顺序为：
静态代码块
匿名代码块
构造方法
===========
匿名代码块
构造方法
*/
}
## 抽象类
**abstract** 修饰符可以用来修饰方法也可以修饰类
若修饰方法，则该方法就是抽方法
若修饰类，那么该类就是抽象类
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明抽象类
抽象类，不能使用new关键字来创建对象，是用来让子类继承的
抽象方法，只有方法的声明，没有方法的实现，是用来让子类实现的
子类继承抽象类，就必须要实现抽象类没有实现的抽方法，否则该子类也要声明抽象类
浙公网安备 33010602011771号