面向对象编程
什么是面向对象
一个类调用另一个类中的方法:
//学生类
public class Student {
//静态方法,通过"类名.方法名"调用
public static void say(){
System.out.println("学生说话了");
}
//非静态方法,通过"对象名.方法名"调用
public void say01(){
System.out.println("01说话了");
}
}
public class Demo02 {
public static void main(String[] args) {
//静态方法调用
Student.say();
//非静态方法调用
Student student = new Student();
student.say01();
}
//和类一起加载的
public static void a(){
//b();//会报错
}
//类实例化之后才加载的
public void b(){
}
}
值传递:
//Java是值传递
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;
}
}
引用传递:
//引用传递:对象,本质还是值传递
//对象-内存
public class Demo05 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);//null
Demo05.change(person);
System.out.println(person.name);//超人
}
public static void change(Person people){
//people是一个对象:指向->Person person = new Person();
//这是一个具体的人,可以改变属性
people.name = "超人";
}
}
//定义一个Person类,有一个属性:name
class Person{
String name;//默认为null
}
创建与初始化对象
new
package com.oop.demo02;
//学生类
public class Student {
//属性:字段
String name;//null
int age;//0
//方法
public void study(){
System.out.println(this.name + "在学习");
}
}
package com.oop.demo02;
//应用类,一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类:抽象,实例化
//类实例化后会返回一个自己的对象
//mike对象就是一个Student类的具体实例
Student mike = new Student();
mike.name = "麦克";
mike.age = 20;
System.out.println(mike.name + mike.age);//麦克20
}
}
构造器
package com.oop.demo02;
//java文件 编译后-> class文件
public class Person {
//一个类即使什么都不写,它也会存在一个方法
//显示定义构造器
String name;
int age;
//alt + insert 快速定义构造器
//1.使用new关键字,本质是在调用构造器
//2.用来初始化值
public Person() {
}
//有参构造:一旦定义了有参构造,无参就必须显示定义,否则不能实例化没有参数的对象
public Person(String name) {
this.name = name;
}
public Person(String name, int age){
this.name = name;
this.age = age;
}
}
/*
构造器:
1.和类名相同
2.没有返回值
作用:
1.new本质在调用构造方法
2.初始化对象的值
注意点:
1.定义有参构造之后,如果想使用无参构造,显示的定义一个无参的构造
Alt + Insert
this. =
*/
package com.oop.demo02;
//应用类,一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//new 实例化一个对象
Person person = new Person("chaoren",20);
System.out.println(person.name);
}
}
总结:
-
类与对象
类是一个模板:抽象,对象是一个具体的实例
-
方法
定义、调用!
-
对应的引用
引用类型:除基本类型(8种)外都是引用类型
对象是通过引用来操作的:栈—>堆
-
属性:字段Field 成员变量
默认初始化:
数字:0,0.0
char:u0000
boolean:false
引用:null
修饰符 属性类型 属性名 = 属性值!
-
对象的创建和使用
- 必须使用new 关键字创建对象,构造器
Person chaoRen = new Person(); - 对象的属性 chaoRen.name
- 对象的方法 chaoRen.sleep()
- 必须使用new 关键字创建对象,构造器
-
类:
静态的属性 属性
动态的行为 方法
-
封装、继承、多态
封装
package com.oop.demo04;
//类 private:私有
public class Student {
//属性私有
private String name;//名字
private int id;//学号
private char gender;//性别
private int age;
//提供一些可以操作这个属性的方法
//提供一些public的get、set方法
//get获得这个数据
public String getName(){
return this.name;
}
//set给这个数据设置值
public void setName(String name){
this.name = name;
}
//alt + insert
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>120 || age<0){//不合法
this.age = 3;
}else{
this.age = age;
}
}
}
package com.oop.demo04;
/*
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());//3
}
}
继承
object类
在Java中,所有的类,都默认直接或者间接继承Object
super-this
package com.oop.demo05;
//人:父类
public class Person {
public Person() {
System.out.println("Person无参执行");
}
//保护:可用super调用
protected String name = "父类名字";
//private:私有的无法被继承,super也调用不了
public void print(){
System.out.println("Person");
}
}
package com.oop.demo05;
//子类继承父类,就会有父类的全部方法
//学生 is 人 :派生类,子类
public class Student extends Person {
public Student() {
//无参构造器中的隐藏代码:"super();"调用了父类的无参构造
super();//调用了父类的构造器,必须在子类构造器的第一行
//this("nihao");//this的有参构造也要放在第一行,所以和上面的super只能二选一,不能一起用
System.out.println("Student无参执行");
}
//有参构造
public Student(String name) {
this.name = name;
}
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);//父类名字
}
}
package com.oop.demo05;
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.test("超人");
s1.test1();
}
}
/*
super注意点:
1.super调用父类的构造方法,必须在构造方法的第一个
2.supper必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法
Vs this:
代表的对象不同:
this: 本身调用者这个对象
super: 代表父类对象的引用
前提:
this: 没有继承也可以使用
supper: 只能在继承条件下才可以使用
构造方法:
this(): 本类的构造
supper(): 父类的构造!
*/
重写
重写都是方法的重写,和属性无关
package com.oop.demo05;
public class B {
//静态
/*public static void test(){
System.out.println("B->test()");
}*/
//非静态
public void test(){
System.out.println("b->test()");
}
}
package com.oop.demo05;
public class A extends B {
/*public static void test(){
System.out.println("A->test()");
}*/
//Override 重写
@Override//注解:有功能的注释
public void test() {
//super.test();
System.out.println("A->test()");
}
}
package com.oop.demo05;
public class Application {
public static void main(String[] args) {
A a = new A();
//父类的引用指向了子类
B b = new A();
//当A类和B类使用有static时的静态方法
//a.test();//A->test()
//b.test();//B->test()
//当A类和B类使用没有static时的非静态方法
a.test();//A->test()
b.test();//A->test()
/*
1.没有static时,b调用的是对象的方法,
而b是用A类new的对象,因此调用了A的方法。
这种是重写了父类的方法,重写只和非静态有关。
2.有static时,b调用B类的方法,因为b是用B类定义的,
且静态方法是类的方法,而非静态方法是对象的方法。
重写:需要有继承关系,子类重写父类的方法!
1.方法名必须相同
2.参数列表必须相同
3.修饰符:范围可以扩大:
public>protected>default>private
4.抛出的异常:范围,可以缩小但不能扩大
ClassNotFoundException->Exception(大)
重写,子类的方法名和父类必须要一致,方法体不同!
为什么需要重写:
1.父类的功能,子类不一定需要或者不一定满足!
Alt + Insert: Override
*/
}
}
多态
什么是多态
package com.oop.demo06;
public class Person {
public void run(){
System.out.println("父");
}
}
package com.oop.demo06;
public class Student extends Person {
@Override
public void run() {
//super.run();
System.out.println("子");
}
public void eat(){
System.out.println("eat");
}
}
package com.oop.demo06;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的(new-实例)
//new Student();
//new Person();
//可以指向的引用类型就不确定了:父类的引用指向子类
//Student能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
//Person父类型,可以指向子类,但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//子类没有重写父类时
//s2.run();//父
//s1.run();//父
//子类重写父类方法时
s2.run();//子
s1.run();//子
//此Person类应用 并没有 指向子类的实例,所以调用的是父类自己的方法
Person p1 = new Person();
p1.run();//父
//对象能执行哪些方法,主要看对象左边的类型,和右边关系不大
//Person s3 = new Student();
//Person类中并没有"eat()方法"
//s3.eat();//报错
s1.eat();//eat
//把Person类型强制转换成Student类型,就能调用子类方法
((Student) s2).eat();//eat
}
}
/*
多态注意事项:
1.多态是方法的多态,属性没有多态
2.父类和子类,有联系 类型转换异常! ClassCastException!
3.存在条件:继承关系,方法需要重写,父类引用指向子类对象!
Father f1 = new Son();
不能重写的:
1.static方法:属于类,不属于实例
2.final常量
3.private方法:私有的
*/
instanceof
用于判断两个对象之间是否有父子关系
package com.oop.demo06;
public class Person {
}
package com.oop.demo06;
public class Student extends Person {
}
package com.oop.demo06;
public class Teacher extends Person {
}
package com.oop.demo06;
public class Application {
public static void main(String[] args) {
//继承关系有下列三种:
//Object->String
//Object->Person->Teacher
//Object->Person->Student
Object object01 = new Student();
//System.out.println(x instanceof y);
//编译能不能通过主要看x和y之间是否有(继承)关系
//编译通过后,得出的结果有true和false
//true:y和x有继承关系
//false:y和x没有继承关系
/*1.编译判断:
可以理解为左边的引用类型和右边用来比较的类型为一条线,
如果这条线没有父子关系,编译就不通过
比如下方的"object01"的引用类型为"Object",
用来比较的类型为"object01 instanceof Student"中的"Student"
且它们两个都在Object->Person->Student,可看出有父子关系,所以编译通过
2.true和false判断:
编译通过后,"object01"是"new Student"实例化的对象,所以对象是Student类型
和"object01 instanceof Student"中的"Student"
都是在Object->Person->Student的继承关系中,所以结果为true
总结:编译能否通过看左边的引用类型,true和false看右边new实例化出来的对象类型
*/
System.out.println(object01 instanceof Student);//true
System.out.println(object01 instanceof Person);//true
System.out.println(object01 instanceof Object);//true
System.out.println(object01 instanceof Teacher);//false
System.out.println(object01 instanceof String);//false
System.out.println("==========");
Person person01 = new Student();
System.out.println(person01 instanceof Student);//true
System.out.println(person01 instanceof Person);//true
System.out.println(person01 instanceof Object);//true
System.out.println(person01 instanceof Teacher);//false
//System.out.println(person01 instanceof String);//编译就报错
System.out.println("==========");
Student student01 = new Student();
System.out.println(student01 instanceof Student);//true
System.out.println(student01 instanceof Person);//true
System.out.println(student01 instanceof Object);//true
//System.out.println(student01 instanceof Teacher);//编译就报错
//System.out.println(student01 instanceof String);//编译就报错
}
}
类型转换
package com.oop.demo06;
public class Person {
}
package com.oop.demo06;
public class Student extends Person {
public void go(){
System.out.println("go");
}
}
package com.oop.demo06;
public class Application {
public static void main(String[] args) {
//类型之间的转换:父(高) 子(低)
//低->高不用强制转换;高->低需要强制转换
//高 低
Person obj = new Student();
//obj.go();//报错
//将obj对象转换成Student类型,我们就可以使用Student类型的方法
Student student02 = (Student) obj;
student02.go();//go
//简写
((Student) obj).go();//go
Student student03 = new Student();
student03.go();//go
Person person02 = student03;//低->高
//person02.go();//报错
//所以子类转换为父类,可能丢失自己本来的一些方法!
}
}
/*
1.只有父类引用指向子类对象(子类引用是不能指向父类对象的)
2.把子类转换为父类,向上转型
3.把父类转换为子类,向下转型:强制转换
4.转换是为了方便方法的调用,减少重复的代码!
抽象:封装、继承、多态!
*/
static关键字详解
package com.oop.demo07;
//static:静态-都是class类一加载就加载出来的
public class Student {
private static int age;//静态的变量 多线程使用的多
private double score;//非静态的变量
public void run(){go();}
public static void go(){}
public static void main(String[] arg){
Student s1 = new Student();
System.out.println(Student.age);
System.out.println(s1.age);
System.out.println(s1.score);
new Student().run();
Student.go();
go();
}
}
package com.oop.demo07;
public class Person {
{
//代码块(匿名代码块)
//用于赋初始值
System.out.println("匿名代码块");
}
static{
//静态代码块
//类一加载就执行,且只执行一次
System.out.println("静态代码块");
}
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person01 = new Person();
/*
输出:
1.静态代码块
2.匿名代码块
3.构造方法
*/
System.out.println("==========");
Person person02 = new Person();
/*
输出:
1.匿名代码块
2.构造方法
*/
}
}
package com.oop.demo07;
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
public static void main(String[] args) {
//Math.random() 随机返回一个随机数
System.out.println(Math.random());
//如果想简写为random(),需要 静态导入包
System.out.println(random());
System.out.println(PI);
}
}
//通过final修饰的类不能被继承,即没有子类
public final class Person {
}
抽象类
package com.oop.demo08;
//abstract 抽象类
//类 extends:单继承 但是接口可以多继承
public abstract class Action {
//约束~有人帮我们实现~
//abstract,抽象方法,只有方法名,没有方法的实现!
public abstract void doSomeThing();
}
/*
特点:
1.不能new这个抽象类,只能靠子类去实现它:约束!
2.抽象类中可以写普通方法
3.抽象方法必须在抽象类中
抽象的抽象:约束
子类继承父类后,需要通过父类的构造器来实例化,所以抽象类也需要构造器
抽象类存在的意义:把公有的抽象出来,为了使代码更简约
*/
package com.oop.demo08;
//抽象类的所有方法,继承了它的子类,都必须实现它的方法,除非子类也是抽象类
public class A extends Action{
@Override
public void doSomeThing() {
}
}
接口
package com.oop.demo09;
//重要是锻炼抽象的思维,这个很难,少数厉害的人才能因此做到架构师
//interface 定义的关键字,接口都需要有实现类
public interface UserService {
//接口中定于的属性都是静态常量 public static final
int AGE = 99;
//接口中所有定义的方法其实都是抽象的,默认都是:public abstract
void add(String name);//添加名字
void delete(String name);//删
void update(String name);//改
void query(String name);//查
}
/*
作用:
1.约束
2.定义一些方法,让不同的人实现
3.方法->public abstract
4.常量->public static final
5.接口不能被实例化,因为接口中没有构造方法
6.implements可以实现多个接口
7.必须要重写接口中的所有方法
*/
package com.oop.demo09;
public interface TimeService {
void timer();
}
package com.oop.demo09;
//类 可以实现接口 implements 接口
//实现了接口的类,就需要重写接口中的所有方法
//利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService {
@Override
public void add(String name) { }
@Override
public void delete(String name) { }
@Override
public void update(String name) { }
@Override
public void query(String name) { }
@Override
public void timer() { }
}
内部类
package com.oop.demo10;
//外部类
public class Outer {
private int id = 10;
public void out(){
System.out.println("外部类的方法");
}
//内部类
class Inner{
public void in(){
System.out.println("内部类的方法");
}
//获得外部类的私有属性
//但是如果内部类添加static修饰就没办法访问
//因为静态的类比普通属性更先运行,除非在id属性前也添加static修饰
public void getID(){
System.out.println(id);
}
}
public void method(){
//局部内部类
class B{
public void in(){}
}
}
}
//也是内部类
//一个java类中可以有多个class类,但只能有一个public class
class A{
public static void main(String[] args) {
}
}
package com.oop.demo10;
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();//内部类的方法
inner.getID();//10
}
}
匿名内部类(安卓必备)
package com.oop.demo10;
public class Test {
public static void main(String[] args) {
//没有名字初始化类,不用实例保存到变量中
new Apple().eat();
//匿名类-学习安卓必备技能
//下面的匿名类返回的是"UserService userService"这个对象
new UserService(){
@Override
public void hello() {
}
};
}
}
//内部类
class Apple{
public void eat(){
System.out.println("1");
}
}
//接口
interface UserService{
void hello();
}