一、类与对象的关系
类 抽象的概念
对象 看得见摸得着的具体实体
类实例化后得到对象
创建宠物猫类
package com.alan.animal;
/**
* 宠物猫类
* @author alan
*
*/
public class Cat {
//属性：昵称、年龄、体重、品种
String name; //昵称 String 默认值null
int month; //年龄 int 默认值为 0
double weight; //体重 double 默认值为0.0
String species; //品种
//方法：跑动、吃东西
//跑动的方法
public void run() {
System.out.println("小猫快跑");
}
//对跑动的方法进行重载
public void run(String name) {
System.out.println(name+"快跑");
}
//吃东西的方法
public void eat() {
System.out.println("小猫吃鱼");
}
}
宠物猫类测试
package com.alan.animal;
public class CatTest {
public static void main(String[] args) {
//对象实例化
Cat one = new Cat();
//测试 调用方法
one.eat();
one.run();
one.name = "花花";
//在类没有初始化的情况下，构造函数对其进行默认的赋值 String 为null ,int 为0，double为0.0
System.out.println("name="+one.name);
System.out.println("species="+one.species);
System.out.println("month="+one.month);
System.out.println("weight="+one.weight);
one.run(one.name);
}
}
单一责任原则
一个类只负责一个功能，如果一个类功能太多则耦合性过高，复用的可能性越低。
实例化对象
分为两个部分：
声明对象 Cat one 在栈中开辟一块空间，但是没有赋值为null
实例化对象 new cat(); 在堆里面开辟的一块空间
Cat one = new cat(); // 将堆空间中的地址赋值给栈，栈为指向堆的引用
image.png
构造方法(构造函数)
在new的时候构造方法会被调用，不能被对象单独调用
1、构造方法与类同名且没有返回值。
2、只能在对象实例化的时候调用。
3、当没有指定构造方法时，系统会自动添加无参的构造方法。
4、就近原则，如果使用name=name赋值，会优先选择同一个作用域，进行赋值，所以要使用不同名字，或者用this.name=name 进行赋值。
this关键字
代表当前对象的属性或者方法，例如this.name表示当前这个class的属性。
image.png
image.png
this与创建的对象具有相同的ID值，说明this调用的就是当前的对象
this();可以调用无参构造方法，但是一定是在其他构造方法的第一行。
其他的方法不能调用构造函数。
二、Java封装
将类的某些信息隐藏在类内部，不允许外部程序直接访问。
image.png
只有get方法 是只读属性
只有set方法 是只写属性
创建包
同一个包中不允许出现相同文件名的Cat，引用同名的
package com.alan.test;
import com.alan.animal.Cat;
import com.alan.mechanics.*; //通过.*直接加载到直接的类，不能使用com.alan.*这种方式
public class Test {
public static void main(String[] args) {
com.alan.mechanics.Cat one = new com.alan.mechanics.Cat(); //直接导入的是animal中的Cat,如果需要用mechanics中的需要在代码中加入com等具体的包路径
// System.out.println("调用成功！");
}
}
static关键字
//static 静态 静态成员 类成员 ，所有对象都使用一块内存空间，所以所有的实例化对象，static修饰的值都相同
public static int price; //用static修饰后 price变为斜体
1、类对象共享该内存信息
2、类加载时产生，直到类销毁的时候释放。生命周期长。
3、静态成员的访问方式，既可以通过对象名访问，也可以通过类名访问。
one.price (对象名访问) Cat.price(类名访问)
4、当static修饰方法时，该方法为静态方法,推荐采用类名调用，如Cat.eat();
5、有静态的属性和方法，静态方法中不能直接访问同一个类的非静态成员，只能直接调用同一个类中的静态成员。只能通过实例化后进行访问没有静态的类，没有静态的局部变量。
代码块{}
普通代码块：在方法中的代码块叫做普通代码块。顺序执行，先出现，先执行。
构造代码块：在类中的代码块叫构造代码块。创建对象时调用，优先与构造方法执行。
静态代码块：构造代码块加上static关键字，就是静态代码块。类加载时调用，优先于构造代码块执行。 无论实例化多少个对象，只执行一次。
command+shift+f 行内容过长，换行快捷键。
三、Java封装综合案例
在方法中通过对象作为参数，传递的是它的引用，可以通过引用获取该对象的所有信息。
数组未实例化会造成空指针异常 java.lang.NullPointerException
package com.alan.model;
/**
* 学生类
*
* @author alan
*
*/
public class Student {
// 成员属性：学号、姓名、性别、年龄、专业对象
private String studentNo;
private String studentName;
private String studentSex;
private int studentAge;
private Subject studentSubject;
// 无参构造
public Student() {
}
// 带参构造
public Student(String studentNo, String studentName, String studentSex, int studentAge,Subject studentSubject) {
this.setStudentNo(studentNo);
this.setStudentName(studentName);
this.setStudentSex(studentSex);
this.setStudentAge(studentAge);
this.setStudentSubject(studentSubject);
}
/**
* 获取专业对象，如果没有实例化，先实例化后再返回
* @return 专业对象
*/
public Subject getStudentSubject() {
if(this.studentSubject == null)
this.studentSubject = new Subject(); //无参构造的重要性就提现出来了
return studentSubject;
}
public void setStudentSubject(Subject studentSubject) {
this.studentSubject = studentSubject;
}
public String getStudentNo() {
return studentNo;
}
public void setStudentNo(String studentNo) {
this.studentNo = studentNo;
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String studentName) {
this.studentName = studentName;
}
public String getStudentSex() {
return studentSex;
}
public void setStudentSex(String studentSex) {
this.studentSex = studentSex;
}
public int getStudentAge() {
return studentAge;
}
/**
* 给年龄赋值。限定大于10，小于50，否则赋值为18
*
* @param studentAge 传入的年龄
*/
public void setStudentAge(int studentAge) {
if (studentAge < 10 || studentAge > 50)
this.setStudentAge(18);
else
this.studentAge = studentAge;
}
/**
* 学生自我介绍的方法
*
* @return 自我介绍信息，包括姓名、学号、性别、年龄
*
*/
public String introduction() {
String str = "学生信息如下:\n姓名：" + this.getStudentName() + "\n学号：" + this.getStudentNo() + "\n性别："
+ this.getStudentSex() + "\n年龄：" + this.getStudentAge()+ "\n所报专业名称：" + this.getStudentSubject().getSubjectName() + "\n学制年限："
+ this.getStudentSubject().getSubjectLife();
return str;
}
/**
* 学生自我介绍的方法
*
* @param subjectName 所学专业名称
* @param subjectLife 学制年限
* @return 自我介绍信息，包括姓名、学号、性别、年龄、所学专业名称、学制年限
*/
public String introduction(String subjectName, int subjectLife) {
String str = "学生信息如下:\n姓名：" + this.getStudentName() + "\n学号：" + this.getStudentNo() + "\n性别："
+ this.getStudentSex() + "\n年龄：" + this.getStudentAge() + "\n所报专业名称：" + subjectName + "\n学制年限："
+ subjectLife;
return str;
}
/**
* 学生自我介绍的方法
* @param sub1 传入学科对象
* @return 自我介绍信息，包括姓名、学号、性别、年龄、所学专业名称、学制年限
*/
public String introduction(Subject sub1) {
String str = "学生信息如下:\n姓名：" + this.getStudentName() + "\n学号：" + this.getStudentNo() + "\n性别："
+ this.getStudentSex() + "\n年龄：" + this.getStudentAge() + "\n所报专业名称：" + sub1.getSubjectName()
+ "\n学制年限："+sub1.getSubjectLife();
return str;
}
}
学科类
package com.alan.model;
public class Subject {
// 成员属性：学科名称、学科编号、学制年限、选课学生数组、报名选修的学生个数
private String subjectName;
private String subjectNo;
private int subjectLife;
private Student[] myStudents;
private int studentNum;
// 无参构造方法，定义一下，防止出现意外的错误。
public Subject() {
}
// 带参构造方法 对学科名称、学科编号、学制年限赋值
public Subject(String subjectName, String subjectNo, int subjectLife) {
this.setSubjectName(subjectName); // 尽量采用此种赋值方式，而不用this.subjectName=subjectName
this.setSubjectNo(subjectNo); // 因为set方法中有时候会包含一些逻辑校验
this.setSubjectLife(subjectLife);
}
// 带参构造方法 对全部属性赋值
public Subject(String subjectName, String subjectNo, int subjectLife,Student[] myStudent) {
this.setSubjectName(subjectName); // 尽量采用此种赋值方式，而不用this.subjectName=subjectName
this.setSubjectNo(subjectNo); // 因为set方法中有时候会包含一些逻辑校验
this.setSubjectLife(subjectLife);
this.setMyStudents(myStudent);
}
/**
* 获取选修专业学生信息，如果保存学生信息的数组没有被初始化，则初始化长度为200
* @return 保存学生信息的数组
*/
public Student[] getMyStudents() {
if(myStudents == null)
myStudents = new Student[200];
return myStudents;
}
public void setMyStudents(Student[] myStudents) {
this.myStudents = myStudents;
}
public String getSubjectName() {
return subjectName;
}
public void setSubjectName(String subjectName) {
this.subjectName = subjectName;
}
public String getSubjectNo() {
return subjectNo;
}
public void setSubjectNo(String subjectNo) {
this.subjectNo = subjectNo;
}
public int getSubjectLife() {
return subjectLife;
}
// 设置学制年限，必须大于0
public void setSubjectLife(int subjectLife) {
if (subjectLife <= 0)
return;
this.subjectLife = subjectLife;
}
public int getStudentNum() {
return studentNum;
}
public void setStudentNum(int studentNum) {
this.studentNum = studentNum;
}
/**
* 专业介绍的方法
* @return 专业介绍的相关信息 专业名称、专业编号、学制年限
*/
public String info() {
String str = "专业信息如下： \n" + "专业名称：" + this.getSubjectName() + "\n专业编号：" + this.getSubjectNo() + "\n学制年限："
+ this.getSubjectLife();
return str;
}
public void addStudent(Student stu) {
//1、将学生保存到数组中
for(int i=0;i
if(this.getMyStudents()[i]==null) {
this.getMyStudents()[i] = stu;
//2、将学生的个数保存到studentNum中
this.studentNum = i+1;
return;
}
}
}
}
测试
package com.alan.test;
import com.alan.model.Student;
import com.alan.model.Subject;
public class NewTest {
public static void main(String[] args) {
Subject sub1 = new Subject("计算机科学与应用","J0001",4);
System.out.println(sub1.info());
System.out.println("=======================");
Student stu1 = new Student("S01","张三","男",58,sub1);
System.out.println(stu1.introduction());
System.out.println("=======================");
Student stu2 = new Student("S02","李四","男",19,sub1);
System.out.println(stu2.introduction("计算机科学与技术", 4));
System.out.println("=======================");
Student stu3 = new Student("S03","王五","女",17,sub1);
System.out.println(stu3.introduction(sub1));
System.out.println("=======================");
sub1.addStudent(stu1);
sub1.addStudent(stu2);
sub1.addStudent(stu3);
System.out.println("学生的总数为："+sub1.getStudentNum());
}
}
四、Java继承
子类继承父类可以直接获取父类的非私有成员(包括属性和方法)
command+shift+o 快速导入包
父类不能访问子类的特有成员(包括属性和方法)
方法重写
1、子类重写父类的方法
2、方法名相同、参数列表相同(参数顺序、个数、类型)，方法返回值相同
3、方法的访问修饰符是允许有变化的，但是访问范围要大于等于父类的访问范围)
4、与方法参数名无关(string name)可以换成(string month)
访问修饰符
private 修饰的成员(属性和方法)只能在本类中访问
public 修饰的成员(属性和方法)访问范围最大，可以在本类、子类、跨包中访问。
protected 修饰的成员(属性和方法) 可以在本类，同包子类，同包非子类，跨包子类使用。跨包非子类中不允许
默认 修饰的成员(属性和方法) 可以在本类，同包子类，同包非子类，不允许在跨包子类/非子类访问
image.png
super关键字
父类对象的引用，当子类中重写父类方法，需要调用父类的原有方法，需要加上super关键字。
子类构造默认调用父类的无参构造，可以通过super关键字调用父类允许被访问的其他构造方法。必须放在第一行
继承的初始化顺序
首先加载父类的静态成员，父类的静态代码块
接着加载子类的静态成员，子类的静态代码块
父类的成员属性赋值
父类的构造代码块
父类的构造函数
子类的构造代码块
子类的构造函数
image.png
this 与 super 分别指定当前类和父类 不能在静态方法中使用
image.png
Object类
Object类是所有类的父类
Object中的 equals 相当于== 比较两个字符串的引用是否相同
String中的 equals 被重写 比较两个字符串的值是否相等
tostring也是重写率非常高的一个方法
/*tostring测试
* 1、输出对象名时，默认会调用toString方法
* 2、输出对象为：类型信息+@+地址信息 如：com.alan.animal.Animal@7b1d7fff
* */
final关键字
final修饰class表示该类没有子类，不允许被继承。
String类 System类都是final修饰的
final 修饰方法，该方法不允许被重写，但是可以正常被子类继承使用
final 修饰方法内局部变量，该局部变量不允许被再次修改。
final 修饰类成员属性，没有赋值的话，只能在构造函数或者构造代码块中进行赋值
final修饰引用类型的变量，初始化后不能再指向另一个对象，但对象的内容可以改变。
注释简介
快捷键 option+/
@Override 给编译器看的，编译之后注解就没有用了。
五、Java设计模式
image.png
单例模式
目的：使类的一个对象成为该类系统的唯一的实例。
定义：一个类有且仅有一个实例，并且自行实例化向整个系统提供
image.png
饿汉式代码实现
线程安全的
package com.alan.singleton;
//饿汉式：创建对象实例的时候直接初始化
public class SingletonOne {
//1、创建类中的私有构造
private SingletonOne() {
}
//2、创建该类型的私有静态实例
private static SingletonOne instance = new SingletonOne();
//3、创建公有静态方法返回静态实例对象
public static SingletonOne getInstance() {
return instance;
}
}
测试
import com.alan.singleton.SingletonOne;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
// SingletonOne one = new SingletonOne(); 构造方法已经私有化，这种方式不允许
SingletonOne one = SingletonOne.getInstance();
SingletonOne two = SingletonOne.getInstance();
System.out.println(one);
System.out.println(two); //所有的引用都会指向同一个对象
}
}
懒汉式代码实现
线程不安全的
通过1、同步锁 2、双重校验锁 3、静态内部类 4、枚举 解决线程不安全问题。
package com.alan.singleton;
// 懒汉式单例模式
public class SingletonTwo {
// 1、创建私有构造方法
private SingletonTwo() {
}
// 2、创建私有静态实例,静态的实例被共享，一定需要此修饰符
private static SingletonTwo instance = null;
// 3、创建静态公有方法返回静态实例对象
public static SingletonTwo getInstance() {
if(instance == null)
instance = new SingletonTwo();
return instance;
}
}
image.png
六、多态
封装和继承都是为多态准备的，是最核心也是最重要的概念。
多态的必要条件：
1、继承
2、重写
3、父类引用指向子类对象
向上转型
package com.alan.test;
import com.alan.animal.Animal;
import com.alan.animal.Cat;
import com.alan.animal.Dog;
public class Test {
public static void main(String[] args) {
Animal one = new Animal();
/* 向上转型、隐式转型、自动转型
父类引用指向子类的对象,可以调用子类重写父类的方法，以及父类派生的方法，无法调用子类独有方法
小类转型为大类
*/
Animal two = new Cat();
Animal three = new Dog();
one.eat();
two.eat();
three.eat();
}
}
向下转型
package com.alan.test;
import com.alan.animal.Animal;
import com.alan.animal.Cat;
import com.alan.animal.Dog;
public class Test {
public static void main(String[] args) {
Animal one = new Animal();
/* 向上转型、隐式转型、自动转型
父类引用指向子类的对象,可以调用子类重写父类的方法，以及父类派生的方法，无法调用子类独有方法
小类转型为大类
*/
Animal two = new Cat();
Animal three = new Dog();
one.eat();
two.eat();
three.eat();
System.out.println("============================");
/*向下转型、强制类型转换
* 子类引用指向父类对象、此处必须进行强转，可以调用子类特有的方法
* 必须满足转换条件才能转换
* */
Cat temp = (Cat)two;
temp.eat();
temp.run();
}
}
抽象类
抽象类不允许实例化，可以通过向上转型，指向子类实例
image.png
抽象方法
不允许包含方法体；子类中需要重写父类的抽象方法。否则，子类也要设置为抽象类。
包含抽象方法的类一定是抽象类。
抽象类可以没有抽象方法。
接口
package com.alan.tel;
/**
* 具有上网功能的接口
* @author alan
*
*/
//接口可以设置的访问修饰符：public 默认
public interface INet {
//接口中抽象方法可以不写abstract关键字,访问修饰符默认为public
public void network();
//default:默认方法 可以带方法体 jdk1.8之后新增的方法
//可以在实现类中重写，并可以通过接口的引用调用
default public void connection() {
System.out.println("我是接口中的默认方法");
}
//static：静态方法 可以带方法体 jdk1.8之后新增的方法
//不可以在实现类中重写，可以通过接口调用
static void stop() {
System.out.println("我是接口中的静态方法");
}
//接口中可以包含常量，默认会自动加上public final static
int TEMP =20;
}
一个类可以实现多个接口
继承的父类和实现的接口中有同名方法，默认是实现父类中的同名方法。
继承的父类的属性和接口中的常量同名，编译器无法分辨，会报错。
接口也可以实现继承关系，并且可以继承多个父接口
内部类
在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。
与之对应，包含内部类的类叫外部类。
分为：1、成员内部类 2、静态内部类 3、方法内部类 4、匿名内部类
成员内部类
package com.alan.people;
//外部类
public class Person {
int age;
public Heart getHeart() {
return new Heart();
}
//成员内部类
/*
* 1、内部类在外部使用时，无法直接实例化，需要借由外部类信息才能完成实例化
* 2、内部类的访问修饰符，可以任意，但是访问范围会受到影响
* 3、内部类可以直接访问外部类的成员；如果出现同名属性，优先访问内部类中的定义
* 4、可以使用外部类.this.成员方式，访问外部类中的同名信息
* 5、外部类访问内部类信息，需要通过内部类实例，无法直接访问。
* 6、内部类编译后.class文件命名：外部类$内部类.class
* */
class Heart{
public String beat() {
return "心脏在跳动";
}
}
}
package com.alan.people;
public class PersonTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Person lili = new Person();
//获取内部类对象实例，方式1:new 外部类. new 内部类
Person.Heart myheart = new Person().new Heart();
System.out.println(myheart.beat());
//获取内部类对象实例，方式2:外部类对象.new 内部类
myheart = lili.new Heart();
System.out.println(myheart.beat());
//获取内部类对象实例，方式3:外部类调用方法返回内部类
myheart = lili.getHeart();
System.out.println(myheart.beat());
}
}
静态内部类
有static修饰，静态内部类对象可以不依赖于外部对象，直接创建。
方法内部类
image.png
扫一扫
2191
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
