面向对象😁
文章为本人随课程记录笔记形成 跟随老师"秦疆（遇见狂神说)" 非常欢迎大家在文章下面留言评论互相交流,也欢迎大家有问题可以联系本人或者本人公众号 😉学思则安
参考课程https://www.kuangstudy.com/course?cid=1
有问题联系我 点我跳转博客首页
方法的学习知识回顾😘
-
修饰符
- 修饰符
- 返回类型
- break:跳出switch,结束循环 和return的区别
- 方法名:注意规范 见名知其意
- 参数列表:(参数类型 ,参数名)…
- 异常抛出
-
方法调用
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传递
-
类方法调用
-
方法一 用到了
static可以直接调用发类方法package com.oop; //学生类 public class Student { //非静态方法 public static void say(){ System.out.println("学生说话了"); } }package com.oop; public class Demo02 { public static void main(String[] args) { Student.say(); } } -
方法二 实例化类 new [一般工作时候常用的方法]
package com.oop; //学生类 public class Student { //非静态方法 public void say(){ System.out.println("学生说话了"); } }package com.oop; public class Demo02 { public static void main(String[] args) { //实例化类 new //对象类型 对象名 =对象值 Student student = new Student(); } }
-
-
调用过程出现错误
-
等于是一个存在的调用不存在的所以这里会报错的
//和类一起加载 //一个存在的东西调用一个不存在的东西 所以在a方法调用b的时候会报错 public static void a(){ b(); } //类实例化之后才会存在 public void b(){ }
-
留下思考补充😍
-
引用传递
-
案例一
package com.oop; public class Demo04 { public static void main(String[] args) { int a=1; System.out.println(a); Demo04.change(a); System.out.println(a); //两个的值都是1 } //返回值为空 public static void change(int a){ a=10; } } -
案例二
package com.oop; //引用传递:对象 本质还是值传递 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 person ){ //person 是一个对象:指向的--->Person person = new Person(); 这是一个具体的人 person.name="迅猛"; } } //定义了一个person类,有一个属性 name class Person{ String name;//null }
-
类与对象的关系🤔
- 类是一种抽象的数据类型,他是对某一类事物整体描述/定义,但是并不能代表一种具体的物体
- 对象是抽象概念的具体实例
如何去创建对象
-
开始规范代码 //一个项目只存在一个main方法
- 学生类
- 每个类里面只有 属性:字段+方法
this代表着这个方法new关键字创建对象:除了分配空间以外,还会给创建好的对象进行默认初始化如age->0 name->null,以及对类中构造器的调用
package com.oop.Demo02; //学生类 public class Student { //属性:字段 String name; int age; //方法 public void study(){ System.out.println(this.name+"在学习"); } }package com.oop.Demo02; //一个项目应该只存在一个main方法 public class Application { public static void main(String[] args) { //类是抽象的 我们需要实例化这个东东 //类实例化后悔返回一个自己的对象 //student对象就是一个Student类的具体事例 Student xiaoming = new Student(); Student xiaohong = new Student(); xiaoming.age=3; xiaoming.name="小明"; System.out.println(xiaoming.age); System.out.println(xiaoming.name); xiaohong.age=3; xiaohong.name="小红"; System.out.println(xiaohong.age); System.out.println(xiaohong.name); } } - 学生类
构造器的使用
-
构造器:
- 和类名相同
- 没有返回值
- 根据调用所穿参数不同
-
作用:
- new 本质在调用构造器
- 初始化一些对象的值
-
注意点:
- 定义有参构造 如果想使用无参构造 显示的定义是一个无参的构造
-
快捷键
ale+insScrLk ->Constructor -
代码
package com.oop.Demo02; //java-->class public class Person { //一个类即使什么都不写 ,也会存在一个方法 //显示的定义构造器 String name; int age; //实例化初始值 //使用new关键字,本质实在调用构造器 //本质是来初始化值 public Person() { } //有参构造:一旦定义了有参构造,无参必须显示定义 public Person(String name) { this.name = name; } public Person(String name, int age) { this.name = name; this.age = age; } }package com.oop.Demo02; //一个项目应该只存在一个main方法 public class Application { public static void main(String[] args) { //使用new 关键词 实例化一个对象 Person person = new Person(); System.out.println(person.name);//kuangshen } }
-
类与对象
类是一个模板:抽象,对象是一个具体的实例 -
方法:
定义和调用
-
对应的引用
引用类型:基本类型(8)对象是通过引用来操作的:栈—>堆
-
属性:字段field 成员变量
默认初始化
数值:0 0.0
char:u0000
boolean:false
引用:null
修饰符 属性类型 属性名=属性值!
-
对象的创建会使用
- 必须使用new 关键字创造对象,构造器 Person kuangshen=new Person();
- 对象的属性 kuangshen.name
- 对象的方法 kuangshen.sleep();
-
类:
静态的属性 属性
动态的行为 方法
封装 继承 多态😁
封装
如何进行封装
- 封装的作用
- 提高程序安全性,保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 提升系统可维护性
- 提高程序安全性,保护数据
- 快捷
alt +ins选择getter和setter 就可以直接使用get set封装方法
package com.oop.Demo04;
//类
public class Student {
//属性私有private 关键字
private String name; //名字
private int num;//学号
private char sex; //性别
private int age;//年龄
//提供一些可以操作这个属性的方法
//提供一些public 的get和 set 方法
//get 获得数据
public String getName(){
return this.name;
}
//set 设定数据
public void setName(String name){
this.name=name;
}
//快捷 alt +ins 选择getter和setter 就可以get set方法
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
//封装的好处就是可以对数据进行合法性判断和约束
public void setAge(int age) {
if(age>150||age<0){
this.age = 3;
}else{
this.age=age;
}
}
}
package com.oop;
import com.oop.Demo04.Student;
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 //因为识别到999不合法
继承
- 继承关键词
extends的意思是"扩展" 子类是父类的扩展 - 一般两个关系 子类和父类 子类可以继承父类所以方法
- 这个地方也用到了上面的封装方法
package com.oop.Demo05;
//Person 人:父类
//子类可以继承父类,会获得父类的所有方法
public class Person {
private int money =10_0000_0000;
public void say(){
System.out.println("说了一句话");
}
//这个地方也是用到了封装方法
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
Object类
- 同时我们发现有存在一个我们看不见的类 叫做
object类 之下有需要本地类 - 在java中所有类都默认直接或者间接继承object类
super与this
-
super子类继承父类通过
super- 同时父类用private私有的东西无法被继承
- 如下当子类父类有相同的方法时候
- print();//当前类的student
this.print();//当前类的student
上面两种写法都访问当前类
- print();//当前类的student
-
super注意点:
- super调用父类的构造方法,必须在构造方法的第一个
- super必须只能出现在子类的方法或者构造方法中
- super和this 不能同时调用构造方法!
-
与this区别
- this:本身调用者这个对象
- super:代表父类对象的应用
- 前提
- this没有继承也可以使用
- super必须要有继承条件才能使用
- 构造方法
- this();本类的构造
- super();父类的构造
-
测试一
package com.oop.Demo05;//学生is 人:派生类,子类
//子类可以继承父类,会获得父类的所有方法
public class Student extends Person{
public void print(){
System.out.println("Student");
}
public void test1 (){
print();//当前类的student
this.print();//当前类的student
super.print();//父类的person
}
}
package com.oop.Demo05;//Person 人:父类
//在java中所有类都默认直接或者间接继承object类
public class Person {
//private私有的东西无法被继承
public void print() {
System.out.println("Person");
}
}
package com.oop;
import com.oop.Demo05.Person;
import com.oop.Demo05.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.test1();
}
}
-
测试二
- 输出结果
System.out.println(name); System.out.println(this.name); System.out.println(super.name); //Sun //出色的你 //csdwpackage com.oop.Demo05; //学生is 人:派生类,子类 //子类可以继承父类,会获得父类的所有方法 public class Student extends Person{ public Student() { private String name="出色的你"; public void test2 (String name){ System.out.println(name); System.out.println(this.name); System.out.println(super.name); } }package com.oop.Demo05; //Person 人:父类 public class Person { protected String name="csdw"; }package com.oop; import com.oop.Demo05.Person; import com.oop.Demo05.Student; public class Application { public static void main(String[] args) { Student student = new Student(); student.test2("Sun"); } } -
隐藏调用代码
- 输出结果
- 父类没有无参子类也不能有
Person父类无参执行了 Person子类无参构造执行了public class Student extends Person{ public Student() { //super();//调用父类构造器代码必须在子类构造器的第一行 //this(name:"hello"); System.out.println("Person子类无参构造执行了"); } }public class Person { public Person() { System.out.println("Person父类无参执行了"); } - 输出结果
方法重写
- 方法重写
- 静态方法:调用只和左边,定义的数据类型有关
- 父类引用指向了子类
- 需要有继承关系,子类重写父类的方法!
- 方法名必须相同
- 参数列表必须相同
- 修饰符:范围可以扩大;[不能缩小] public>Protected>Default>private
- 抛出的异常:范围可以被缩小但是不能放大;[后续再理解]
- 子类方法和父类方法必须一致:方法体不同!
- 为什么需要重写?
- 父类的功能子类不一定需要也不一定满足 用快捷键
alt+ins选用Override Methods
- 父类的功能子类不一定需要也不一定满足 用快捷键
//代码一
package com.oop.Demo05;
//A与B形成父子关系
public class A extends B{
public void test() {
System.out.println("A=>test" );
}
}
package com.oop.Demo05;
//重写和属性无关
public class B {
public void test() {
System.out.println("B=>test");
}
}
package com.oop;
import com.oop.Demo05.A;
import com.oop.Demo05.B;
public class Application {
public static void main(String[] args) {
//方法调用只和左边,定义的数据类型有关
A a = new A();
a.test();//A
//父类引用指向了子类
B b =new A();
b.test();//B
}
}
多态
-
子类能调用的都是自己的或者父类的
父类虽然可以指向子类,但是不能调用子类独有方法
- 就比如下面这个如果是
s2.eat();就会报错无法调用子类方法 - 而且
s2.run(); s1.run();此时子类父类都存在run方法,我们可以知道当子类父类都存在的方法我们优先访问子类方法
- 就比如下面这个如果是
-
多态注意事项
- 多态是方法的多态 没有属性的多态
- 父类和子类,有联系 类型转换异常!
- 存在条件:继承关系 ,方法需要重写,父类引用指向子类对象! Father f1=new Son();
- 无法被从写更没有多态的方法
- static 属于类,他不属于实例
- final 常量;
- private方法,私有方法
- 无法被从写更没有多态的方法
package com.oop.Demo06;
public class Student extends Person{
public void run() {
System.out.println("Student");
}
public void eat() {
System.out.println("Student eat");
}
}
package com.oop;
import com.oop.Demo06.Person;
import com.oop.Demo06.Student;
public class Application {
public static void main(String[] args) {
//可以指向的引用类型就不确定了额:父类的引用指向
//Student能调用的都是自己的或者父类的
Student s1 = new Student();
//Person虽然可以指向子类,但是不能调用子类独有方法
Person s2 = new Student();//父类
Object s3 = new Student();//祖宗
//上面这些 能不能用主要是看左边有没有,与右边关系不大
s2.run();
s1.run();
s1.eat();
}
}
package com.oop.Demo06;
public class Person {
public void run() {
System.out.println("跑的好快");
}
}
instanceof
-
总结
- 父类引用指向子类的对象
- 把子类转换成父类,向上转型可以直接转换
- 把父类转换成子类,向下转型需要强制转换可能会丢失一些方法
- 方便方法的调用 减少重复代码 有效提升利用率
public class Application {
public static void main(String[] args) {
//Object>String
//Object>Person>Teacher
//Object>Person>Student
//instanceof在这里用于判断父子关系
Object object= new Student();
//System.out.println(x instanceof 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);//编译报错
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);//编译报错
//System.out.println(student instanceof String);//编译报错
System.out.println("=================");
}
- 对象类型转换
//类型之间的转换 父 子
//高 低
Person s1 =new Student();
//s1将这个对象转化为Student类型,我们就能使用student 类型的方法了
/**
Student s2 = (Student) s1;
s2.go();
**/
((Student) s1).go();
static
- 静态方法可以直接访问 非静态无法直接访问
- 原因看下面 他们的加载访问级别不一样 所以不能调用
package com.oop.Demo07;
public class Student {
private static int age;//静态的变量
private double score;//非静态的变量
//非静态方法
public void run() {
System.out.println("run");
}
//静态方法
public static void eat() {
System.out.println("eat");
}
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(Student.age);
System.out.println(s1.age);
//需要先实例化对象才能使用
System.out.println(s1.score);
//可以直接调用
Student.eat();
eat();
//无法调用
//run();
}
}
- 访问优先级别是不一样的
package com.oop.Demo07;
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();
}
}
- 同时在学习中我们注意到 被final修饰以后 无法被继承
- 引用库
import
package com.oop.Demo07;
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Text {
public static void main(String[] args) {
//Math.random()
//Math.PI
System.out.println(random());
System.out.println(PI);
}
}
抽象类
-
abstract抽象方法 只有名字没有方法的实现 -
-
抽象类里面可以有一些普通方法
-
抽象方法必须定义在抽象类里面
-
不能new这个抽象类,只能靠子类去实现它: 约束!!
'Action' is abstract; cannot be instantiated
-
-
抽象存在的意义 抽象出来~提高开发效率
package com.oop.Demo08; //abstract 关键词 抽象类 类 extends:单继承 (接口才能多继承) public abstract class Action { //约束~有人帮我们实现 //abstract 抽象方法 只有名字没有方法的实现 public abstract void doSomething(); public void run(){ System.out.println("汪汪汪"); } }
接口
-
接口的本质是契约
-
interface定义的关键字,接口都需要实现类 -
接口定义
-
接口中的所有定义其实都是抽象的 默认
public abstractpublic abstract void add(String name); void add(String name); -
接口定义常量 默认
public static finalpublic static final int Age=99; int Age=99;
-
-
-
接口的作用
- 约束
- 定义方法让不同的人实现 ~
- 接口不能被实例化[接口中没有构造方法]
- 实现接口必须要重写接口中的方法
Alt +Enter一键生成 - 类可以实现接口
implements接口可以进行多继承 - 多继承~利用接口实现继承
package com.oop.Demo09;
//interface 定义的关键字,接口都需要实现类
public interface UserService {
//接口定义常量 默认 public static final
int Age=99;
//接口中的所有定义其实都是抽象的 默认 public abstract
void add(String name);
void update(String name);
void delete(String name);
void query(String name);
}
package com.oop.Demo09;
public interface TimeService {
void time();
}
package com.oop.Demo09;
//类 可以实现接口 implements 接口 可以继承多个'
//实现了接口的类,就需要重写接口中的方法~
//多继承~利用接口实现继承
public class UserServiceImpl implements UserService,TimeService {
@Override
public void time() {
}
@Override
public void add(String name) {
}
@Override
public void update(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void query(String name) {
}
}
内部类
-
通过外部类来实例化内部类
public class Outer { private int id; public class Inner{ public void in(){ System.out.println("这就是内部类"); } } }Outer outer = new Outer(); Outer.Inner inner = outer.new Inner(); inner.in(); -
内部类可以获得外部类的是私有属性私有方法
public class Outer { private int id=100; public void out(){ System.out.println("这就是外部类方法"); } public class Inner{ public void in(){ System.out.println("这就是内部类"); } //获得外部类的是私有属性私有方法 public void getID(){ System.out.println(id); in(); } } } -
一个java中可以有多个class ,但是只能有一个public class方法
public class Outer { } //一个java中可以有多个class ,但是只能有一个public class方法 class A{ public static void main(String[] args) { } } -
局部内部类
package com.oop.Demo10; public class Outer { public void method(){ //局部内部类 class Inner{ public void in(){ } } } } -
以后再看吧
package com.oop.Demo10; public class Test { public static void main(String[] args) { Apple apple = new Apple(); //没有名字初始化类,不用将实例保存到变量中~ new Apple().eat(); } } class Apple{ public void eat(){ System.out.println("1"); } } interface UserService{ void hello(); }
