1.类:模板,⽤来定义⼀类对象的⽅法和属性,⽐如⼈、学⽣、猫,万物都是有模板,都是可 以定义为类。 (类名⾸字⺟⼤写)
class Student{
} class Person{
} class Cat{
}
对象:类的实例化,⽐如 学⽣这个类实例化,就是 XX同学
Student student = new Student(); Cat cat1 = new Cat(); new Persion();
方法:⽅法是语句的集合,在⼀起完成⼀个功能
⽅法包含于类或对象中,即普通⽅法或者类⽅法
修饰符 返回值类型 ⽅法名(参数类型 参数名){ ... ⽅法体 ... return 返回值; }
继承:⼦类继承⽗类的特征和⾏为,使得⼦类对象具有⽗类的⽅法和属性
⽗类也叫基类,具有公共的⽅法和属性
动物<-猫
动物<-狗
多态
同⼀个⾏为具有多个不同表现形式的能⼒
优点:减少耦合、灵活可拓展
⼀般是继承类或者重写⽅法实现
抽象
关键词abstract声明的类叫作抽象类,abstract声明的⽅法叫抽象⽅法
⼀个类⾥包含了⼀个或多个抽象⽅法,类就必须指定成抽象类
抽象⽅法属于⼀种特殊⽅法,只含有⼀个声明,没有⽅法体
teacher类
package day3; public class Teacher { private int age; private String name; private int sex; public void tech(){ System.out.println("教学"); } public void sleep(){ System.out.println("睡觉"); } }
school类
package day3; public class School { private String name; private String address; private int age; private Teacher [] teachers; public void addTearcher(){ } public void setTeachers(Teacher[] teachers){ this.teachers = teachers; } public Teacher[] getTeachers() { return teachers; } public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setAge(int age){ if(age>0){ this.age = age; System.out.println("设置完成"); }else{ System.out.println("非法参数"); } } public static void main(String [] args){ System.out.println("主入口"); School school = new School(); school.setAge(1); Teacher teacher1 = new Teacher(); teacher1.tech(); } }
2.构造函数:⼀种特殊的⽅法,创建对象时⽤来初始化对象,每次使⽤new 创建对象的时候,就会使⽤构造函数。与类具有相同的名称,但是没有返回值,Java会⾃动为每个类提供⼀个默认构造函数,如果⾃⼰定义了构造函数,就不再使⽤默认构造函数,如果没有显示的写出默认构造函数, 则会消失。
注意点:如果构造函数之间互相调⽤,务必写在⽅法第⼀⾏
构造函数种类
默认构造函数
public 类名(){ }
⽆参构造函数
public 类名(){ //写⾃定义的语句 }
有参构造函数
public 类名(参数类型1 参数名1,参数类型2 参数名2...){ //⾃定义⽅法体 }
构造函数的修饰符
public ⽤的最多,⽤来创建对象
private 私有化构造函数,不给外部创建对象,⽐如⼯具类,或者单例设计模式
default 默认的话,只能在当前包⾥⾯使⽤new 创建对象,⼏乎不⽤
user 类
package day3; //一个类里面可以有多个构造函数 public class User { private int age; private String name; // 构造函数,相当于这个对象初始化 // 如果构造函数之间互相调用,务必写在方法第一行 public User(){ System.out.println("这是默认构造函数"); this.age = age; } public User(String name, int age){ this.name = name; this.age = age; } public void setAge(int age){ if(age>0){ this.age = age; }else{ System.out.println("非法参数"); } } public int getAge(){ return age; } public String getName(){ return name; } public void setName(String name){ this.name = name; } public void sleep(){ System.out.println("睡觉"); String name = this.getName(); System.out.println(name+"在睡觉"); } public void sleep(String address){ System.out.println(address); System.out.println("睡觉"); } }
maintest类
package day3; public class MainTest { public static void main(String [] args){ // test1(); // test2(); test3(); } public static void test3(){ User user = new User(); } public static void test2(){ String name = "一把手"; int age = 5; User u = new User(name,age); User u2 = new User(); System.out.println(u.getName()); } public static void test1(){ User user = new User(); user.setAge(10); System.out.println(user.getAge()); user.setName("大爷灰"); System.out.println(user.getName()); } }
3.封装
封装是把过程和数据包围起来,对数据的访问只能通过已定义的接⼝即⽅法
在java中通过关键字private,protected和public实现封装。什么是封装?封装把对象的所有组成部分组合在⼀起,封装定义程序如何引⽤对象的数据,封装实际上使⽤⽅法将类的数据隐藏起来,控制⽤户对类的修改和访问数据的程度。 适当的 封装可以让代码更容易理解和维护,也加强了代码的安全性.
类封装
⽅法封装
overload(重载,过载)
在⼀个类⾥⾯,⽅法名字相同,⽽参数不同,和返回类型⽆关
override(重写,覆盖)
⼦类对⽗类的允许访问的⽅法的实现过程进⾏重新编写, 返回值和形参都不能改变
返回值类型,⽅法名,参数类型以及个数
⼦类能够根据需要实现⽗类的⽅法
3.this关键字
当⼀个对象创建后,JVM会给这个对象分配⼀个引⽤⾃身的指针,这个指针的名字就是 this
只能⽤于⾮静态⽅法体内,静态⽅法和代码块不能出现this
this就是指向当前对象本身
使⽤场景:
this(参数类型1 参数名,...) 表示当前类对应的构造函数
⽅法形参和对象的属性重名,⽤this来区分
public void setAge(int age){ this.age = age; }
4,继承
⼦类继承⽗类的特征和⾏为,使得⼦类对象具有⽗类的⽅法和属性
⽗类也叫基类,具有公共的⽅法和属性,⽣活中的例⼦
动物<-猫
动物<-狗
java中的继承,减少重复代码
格式,通过extends关键字
class ⽗类名称{ } class ⼦类名称 extends ⽗类名称{ }
特点
⼦类拥有⽗类的⾮private的属性和⽅法
⼦类可以⽤⾃⼰的⽅式实现⽗类的⽅法 override(重写,覆盖)
实现了代码的复⽤
重写从⽗类那⾥继承来的⽅法的,当调⽤⽅法时候会优先调⽤⼦类的⽅法(默认就近原则)
注意:
不⽀持多继承,⽀持多重继承,多重继承提⾼了耦合性,组合优于继承
所有的类都是继承于 java.lang.Object
final关键字
修饰的类,则这个类不可以被继承
修饰⽅法,则这个⽅法不允许被覆盖(重写)
living类
package day3; public class Living { public void run(){ System.out.println("运动"); } }
animal类
package day3; public class Animal extends Living{ private String name; private int 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 sleep(){ System.out.println("闭着眼睛睡觉"); } }
dog类
package day3; public class Dog extends Animal{ public void eat(){ System.out.println("狗吃骨头"); } @Override public void sleep(){ System.out.println("狗白天不着眼睛睡觉"); } public void test(){ //调用父类的方法,super表示父对象的引用 super.sleep(); //调用当前类的方法,this表示当前对象的引用 this.sleep(); } }
EetendsMainTest类
package day3; public class EetendsMainTest { public static void main(String [] args){ Dog dog = new Dog(); dog.setAge(1); dog.setName("旺财"); System.out.println(dog.getAge()); dog.sleep(); dog.eat(); dog.test(); } }
5.继承
⼀个引⽤变量,⽤于引⽤⽗类对象
⽗类和⼦类都具有相同的命名⽅法,要调⽤⽗类⽅法时使⽤
⽗类和⼦类都具有相同的命名属性,要调⽤⽗类中的属性时使⽤
super也是⽗类的构造函数,格式 super(参数)
注意点 调⽤super() 必须是类构造函数中的第⼀条语句,否则编译不通过
注意
每个⼦类构造⽅法的第⼀条语句,都是隐含地调⽤super(),如果⽗类没有这种形式的构造函 数,那么在编译的时候就会报错
public class Father { public Father(){ System.out.println("father ⽆参构造函数"); } } public class Children extends Father{ public Children(){ //默认存在,写和不写都⾏ super(); System.out.println("Child⽆参构造函数"); } }
this()和super()都指的是对象,均不可以在static环境中使⽤
包括:static变量,static⽅法,static语句块。
构造函数 super和this
this 和super在构造函数中只能有⼀个,且都必须是构造函数当中的第⼀⾏
当⽗类的构造函数是⽆参构造函数时,在⼦类的构造函数中,不⽤显式super()去调⽤⽗类的 构造函数,
当⽗类的构造函数是有参构造函数时,如果⼦类的构造函数中不写super()进⾏调⽤⽗类的构造函数,编译器会报错。
java继承后类的初始化顺序
问题:静态代码块、⾮静态代码、⽗类/⼦类⽆参构造⽅法、⽗类/⼦类的⼀般⽅法
father类
package day3; public class Father { static { System.out.println("父类静态代码块"); } public Father(){ System.out.println("father 无参构造函数"); } public Father(int age){ System.out.println("father 有参构造函数"); } public void sleep(){ System.out.println("father sleep方法"); } }
children类
package day3; public class Children extends Father{ static { System.out.println("Child静态模块"); } public Children(){ System.out.println("Child 无参构造函数"); super.sleep(); } public void sleep(){ System.out.println("Child sleep方法"); } }
SuperTest类
package day3; public class SuperTest { public static void main(String [] args){ new Children().sleep(); } }
6.抽象
需求:动物都有年龄和名称,但是吃的不⼀样,⽺吃草,⽼⻁吃⾁,但是都是闭着眼睛睡觉的
⻋,都有名称和价格,也有跑的⽅法,但是最⾼速度或者动⼒来源不⼀样
当⽗类的某些⽅法不确定时,可以⽤abstract关键字来修饰该⽅法,即抽象⽅法,⽤abstract 来修饰该类,即抽象类
抽象类将事物的共性的东⻄提取出来,由⼦类继承去实现,代码易扩展、易维护
java中的抽象类和抽象⽅法
//抽象类 abstract class 类名{ } //抽象⽅法,不能有⽅法主体 abstract 返回类型 ⽅法名();
Vehicle类
package day4; public abstract class Vehicle { public abstract void run(); public void stop(){ System.out.println("停在路上"); } }
Bicycle类
package day4; public class Bicycle extends Vehicle{ @Override public void run() { System.out.println("人力驱动"); } }
Auto类
package day4; public class Auto extends Vehicle { @Override public void run() { System.out.println("汽油驱动"); } }
AbstractTest类
package day4; public class AbstractTest { public static void main(String [] args){ Bicycle bicycle = new Bicycle(); Auto auto = new Auto(); bicycle.run(); bicycle.stop(); auto.run(); auto.stop(); // 不能 new 抽象类 // new Vehicle(); } }
抽象特点:
抽象类的特点
抽象类不能被实例化,因为抽象类中⽅法未具体化,这是⼀种不完整的类,所以不能直 接实例化,编译⽆法通过
抽象类中不⼀定包含抽象⽅法,但是有抽象⽅法的类必定是抽象类
如果⼀个抽象类中可以没有抽象⽅法,这样做的⽬的是为了此类不能被实例化。
抽象类的⼦类必须给出抽象类中的抽象⽅法的具体实现,否则⼦类也是抽象类,需要⽤ abstract声明
抽象类不能使⽤final关键字修饰,因为final修饰的类是⽆法被继承
抽象⽅法的特点
抽象类中的抽象⽅法只是声明,不包含⽅法体
抽象⽅法不能⽤private修饰,因为抽象⽅法必须被⼦类实现(覆写),⽽private权限 对于⼦类来 说是不能访问的
⼀个类继承了⼀个抽象类,那么它必须全部覆写抽象类中的抽象⽅法,当然也可以不全 部覆写,如果 不覆写全部抽象⽅法则这个⼦类也必须是抽象类
构造⽅法,类⽅法(即static 修饰的⽅法)不能声明为抽象⽅法
7.接口
是抽象⽅法的集合,接⼝通常以interface来声明,⼀个类通过继承接⼝的⽅式,从⽽来继承 接⼝的抽象⽅法
语法
interface 名称 [extends 其他的接⼝名] { // 声明变量 // 抽象⽅法 int getMoney(); }
接⼝的特点
接⼝的⽅法都是抽象⽅法,默认都是 public abstract,其他修饰符都会报错
接⼝中可以含有变量,但是接⼝中的变量会被隐式的指定为 **public static final**
类描述对象的属性和⽅法,⽽接⼝则包含类要实现的⽅法
接⼝⽆法被实例化,需要被实现才⾏
⼀个实现接⼝的类,必须实现接⼝内所描述的所有⽅法,否则就必须声明为抽象类
接⼝和类的区别
接⼝没有构造函数
接⼝⾥可以有静态⽅法和⽅法体
接⼝中所有的⽅法必须是抽象⽅法(JDK8之后就不是)
接⼝不是被类继承了,⽽是要被类实现
接⼝⽀持多继承, 类不⽀持多个类继承
接⼝的实现implements
当类实现接⼝的时候,类要实现接⼝中所有的⽅法,不然类必须声明为抽象的类,使⽤ implements关键字实现所有接⼝
语法
class 类名 implements 接⼝名称[, 其他接⼝名称, 其他接⼝名称]{ //要实现的⽅法 }
注意
⼀个类只能继承⼀个类,但是能实现多个接⼝
接⼝能继承另⼀个接⼝,接⼝的继承使⽤extends关键字,和类继承⼀样
JDK8新特性
interface中可以有static⽅法,但必须有⽅法实现体,该⽅法只属于该接⼝,接⼝名直接调⽤ 该⽅法
接⼝中新增default关键字修饰的⽅法,default⽅法只能定义在接⼝中,可以在⼦类或⼦接⼝ 中被重写
default定义的⽅法必须有⽅法体
⽗接⼝的default⽅法如果在⼦接⼝或⼦类被重写,那么⼦接⼝实现对象、⼦类对象,调⽤该 ⽅法,以重写为准
本类、接⼝如果没有重写⽗类(即接⼝)的default⽅法,则在调⽤default⽅法时,使⽤⽗类 定义的default⽅法逻辑
IPay类
package day4; public interface IPay { // static 修饰符定义静态方法 static void staticMethod() { System.out.println("接口中的静态方法"); } // default 修饰符定义默认方法,默认方法不是抽象方法,可以重写也可以不重写 default void defaultMethod() { System.out.println("接口中的默认方法"); } }
Alipay类
package day4; public class Alipay implements IPay { @Override public void defaultMethod() { System.out.println("重写后的方法"); } }
interfaceTest类
package day4; public class interfaceTest { public static void main(String [] args){ IPay.staticMethod(); Alipay alipay = new Alipay(); alipay.defaultMethod(); } }
8.面向对象编程之InstanceOf关键词和多态
InstanceOf 关键词:是Java的⼀个⼆元操作符(运算符),也是Java的保留关键字
作用:判断⼀个类是否实现了某个接⼝,或者判断⼀个实例对象是否属于⼀个类
语法
//如果该object 是该class的⼀个实例,那么返回true。如果该object 不是该class的⼀个实例,或者object是null,则返回false boolean result = object instanceof class 参数: result :boolean类型。 object :必选项。任意对象表达式。 class:必选项。任意已定义的对象类。
对象类型强制转换前的判断
Person p1 = new Student(); //判断对象p是否为Student类的实例 if(1p instanceof Student) { //向下转型 Student s = (Student)p1; }
⽅法重写和重载
⽅法重写 overriede:⼦类对⽗类的允许访问的⽅法的实现过程进⾏重新编写,
注意点
返回值和形参都不能改变
⽗类的成员⽅法只能被它的⼦类重写
final 和 static的⽅法不能被重写
构造⽅法不能被重写
访问权限不能⽐⽗类中被重写的⽅法的访问权限更低
⽅法重载 overload
⼀个类⾥⾯,⽅法名字相同但参数不同,返回类型可以相同也可以不同
⽐如构造函数重载
注意核⼼区分
override是在不同类之间的⾏为,overload是在同⼀个类中的⾏为
总结:Java多态
同⼀个⾏为具有多个不同表现形式或形态的能⼒
常⻅的⽅式:继承⽅法重写、同类⽅法重载、抽象⽅法、接⼝
10.写个计算器,能完成加减乘除运算
定义接⼝做参数
加减乘除定义4个类
定义⼀个静态⼯具类,把下⾯的接⼝作为其中⼀个形参对象,传递具体的运算符类完成计算
ICompute类
package day4; //计算机接口 public interface ICompute { /** * 通过传递两个参数,完成传递 * @param num1 * @param num2 * @return */ int computer(int num1, int num2); }
AddOper类
package day4; public class AddOper implements ICompute { @Override public int computer(int num1, int num2) { return num1 + num2; } }
SubOper类
package day4; public class SubOper implements ICompute { @Override public int computer(int num1, int num2) { return num1 - num2; } }
MulOper类
package day4; public class MulOper implements ICompute { @Override public int computer(int num1, int num2) { return num1*num2; } }
DeviceOper类
package day4; public class DeviceOper implements ICompute { @Override public int computer(int num1, int num2) { try { return num1/num2; }catch (Exception e){ e.printStackTrace(); } return -1; } }
UseComputer类
package day4; public class UseComputer { public static void computer(ICompute compute, int num1, int num2){ int result = compute.computer(num1, num2); System.out.println(result); } public static void main(String [] args){ UseComputer.computer(new AddOper(),25,5); UseComputer.computer(new SubOper(),25,5); UseComputer.computer(new MulOper(),25,5); UseComputer.computer(new DeviceOper(),25,0); } }