面向对象的三大特性: 封装 继承 多态
javabean规范: 1.类是公共的 2.至少提供一个空构造 3.私有的属性 4.公共的访问方式 5.重写toString与equals方法2.1 构造器
2.1.1 构造函数 构造方法
作用: 为对象初始化信息(为对象的成员变量赋值)
使用: 跟随new关键字一起使用,不能单独调用。
注意：
方法名称与当前类名一致；
如果一个类中没有显示的定义构造器,编译器会自动默认提供一个空构造(没有参数的构造器)
如果存在显示定义的构造器,编译器不会再为类型提供任何构造器了,包括空构造
构造器中可以存在return,根据需求定义,实现提前结束构造器,但是不能带出返回值
public Dog(String dogName,int dogAge,String dogType){
System.out.println("这是带参造......");
if(dogAge<0){
System.out.println("年龄不合法无法初始化...");
return;
}
package com.yjxxt.constructor02;
public class Class001_Constructor {
public static void main(String[] args) {
//先创建对象,后赋值
//1.创建对象
//Dog dog = new Dog();
//2.赋值
//dog.name = "花卷";
//dog.age = 4;
//dog.type = "二哈";
//创建对象的同时为成员变量赋值
Dog dog = new Dog("大白",-2,"萨摩");
dog.lookDoor();
//为对象的成员重新赋值
dog.name = "小白";
dog.lookDoor();
}
}
class Dog{
public String name;
public int age;
public String type;
//空构造
public Dog(String dogName,int dogAge,String dogType){
System.out.println("这是带参造......");
if(dogAge<0){
System.out.println("年龄不合法无法初始化...");
return;
}
name = dogName;
age = dogAge;
type = dogType;
}
public void lookDoor(){
System.out.println(name+"正在看家...");
}
}
2.1.2 构造器的重载
两同三不同：
方法名，类名相同
参数列表类型，个数，列表不同
2.2 thispublic Person(String name){//李四
name=pname;
}
将通过带参构造器创建对象时传入的李四作为参数，将其赋值给p2对象的成员变量name。
2.2.1 this.的使用
this.代表当前对象的
this.不可省略，局部变量与成员变量同名的情况下，此时需要通过this.来代表对象的属性（对象的成员变量）
public String name;
public Person(String name){//李四
this.name=name;//局部对象name，赋值给p2对象的成员变量name;
}
不存在同名问题时候,指代成员直接使用省略this.
public void eat(){
System.out.println(this.name+"在吃饭");
}
2.2.2 this()的使用
在构造器的首行用来调用本类中其他构造器 this(参数列表)
注意: 不能多个构造器之间通过this相互调用 this存储指代对象的地址 在构造器中遇到this指代对象,默认代表当前new的对象 在成员方法中的this默认指代调用成员方法的对象 this不能使用在static修饰的方法中2.3 static
2.3.1 static的使用
package com.yjxxt.oop;
public class Class01_Static {
//成员
static int a=1;
int b=10;
public static void main(String[] args){
//局部
int c=3;
//类名调用静态内容
System.out.println(Class01_Static.a);//a=1 类名.静态变量名
Class01_Static.testStatic();//输出 静态方法 类名.静态方法名(参数列表)
//对象
Class01_Static cs=new Class01_Static();
//只能通过对象调用成员
System.out.println(cs.b);//10 对象.静态变量名
cs.test();//成员方法 a=1,b=10 对象.静态方法名(参数列表)
//对象调用静态内容
System.out.println(cs.a);//1
cs.testStatic();//静态方法
testStatic();//静态方法
cs.test();//成员方法 a=1,b=10
}
//静态方法
public static void testStatic(){
System.out.println("静态方法");
}
//成员方法
public void test(){
System.out.println("成员方法");
System.out.println(a);
System.out.println(b);
}
}
2.3.2 static测试用例
package com.yjxxt.oop;
public class Class01_StaticTest {
public static int id;
public int age;
public static void main(String[] args) {
Class01_StaticTest cl = new Class01_StaticTest();//0x001
System.out.println(Class01_StaticTest.id); //0
System.out.println(cl.age); //0
cl.change(); //id= 1 age= 0 //id= cl.age=1
System.out.println(Class01_StaticTest.id); //1
System.out.println(cl.id); //1
System.out.println(cl.age); //age=0
cl.change(); //
System.out.println(id); //2
System.out.println(cl.age); //2
}
public void change() {
Class01_StaticTest cl = new Class01_StaticTest();//0x002 //0x003
cl.age++; //0
Class01_StaticTest.id++; //1
System.out.println("In change(): id = " + id + " age = " + age); //id= 1 age=0 //2 0
System.out.println("In change(): id = " + id + " Class01_StaticTest.age = " +cl.age);
//id=1 Cl.age= 1 // 2 1
}
}
2.4 block块
block 块
{} : 自成作用域
分类: 执行时机:
{}定义在方法中|语句块中 --> 局部代码块 跟随方法的调用
{}定义在类中方法外 ---> 构造块 跟随new一起使用
static{}定义在类中方法外--> 静态块 类第一次加载
同步块
2.4.1 block 的使用及分析
public class Class01_Block {
static int i=10;
String name;
//静态块
static {
System.out.println("我是静态块1……");
}
static {
System.out.println("我是静态块2……");
}
static {
System.out.println("我是静态块3……");
}
//构造器
public Class01_Block(){
System.out.println("我是构造器");
}
public Class01_Block(String name){
System.out.println("我是构造器");
this.name=name;
}
//构造块
{
System.out.println("我是构造块1……");
name="张三";
}
{
System.out.println("我是构造块2……");
}
{
System.out.println("我是构造块3……");
}
//main方法
public static void main(String[] args) {
//局部
int i=5;
//局部代码块
{
System.out.println("我是局部代码块中的代码……");
i=1;
}
System.out.println(i);
System.out.println( new Class01_Block("李四").name);
}
}
2.4.2 block测试用例
package com.yjxxt.oop;
public class Class01_BlockTest {
public static int a = 0;
static {
a = 6;
System.out.println(" 、静态代码块执行a=" + a); //6
}
public Class01_BlockTest() {
this(a); //this()是指向带参构造器的
System.out.println(" 、"+a); //10
System.out.println(" 、无参构造方法执行a=" + a); //10
}
public Class01_BlockTest(int n) {
{
a = 10;
System.out.println(" 、非静态代码块执行a=" + a); //10
}
System.out.println(" 、"+n); //6
System.out.println(" 、"+a);//10
}
public static void main(String[] args) {
//先执行静态块
System.out.println(" 、main"); //main
Class01_BlockTest tsc = new Class01_BlockTest();
}
}
2.5 Debug调试工具
2.5.1 Debug作用
Debug 调试工具 ***** 作用: 1.追踪程序的执行流程 2.定位异常出现的位置 3.观察程序执行过程中变量的变化情况 4.根据追踪程序的执行流程学习第三方框架的源码
2.5.2 使用步骤
步骤: 1.设置断点 在行号的后面鼠标单击设置断点 2.Debug运行 3.debug运行模式下进行调试 Step over F8 : 下一步跳过|略过 如果下一步是方法的调用,不会跟随方法的调用执行,直接进入下一步 Step into F7 : 步入 | 下一步进入 如果下一步是自定义方法的调用,跟随方法的调用执行每一步 Step out shift+f8 : 下一步调出 如果在方法的内部,下一步直接调出到方法调用处 Force step into alt+shift+f7 : 下一步强制进入 如果下一步是方法的调用,包括jdk源码方法的调用,强制进入,跟随执行 Run to Cursor alt+F9 : 直接运行到鼠标光标所在位置2.6 package、import 包和导包
2.6.1 package
package 与 import : 包机制: 文件夹 帮助管理众多的资源 提供了多重命名空间 包信息: 存在与java文件的最上面首行,标识当前类型所在的包路径
2.6.2 import
导包: 指明要使用类型的位置 如果要使用其它类型,可能涉及到导包问题 不需要导包的类: 1)java.lang包下的内容 2)同包类 导包的方式: 1.使用的位置指定类型的全限定名 : 包名.类名 只能在当前位置使用一次,简单方便,但是使用频繁的话建议使用import导包 2.import关键字进行导包 定义语法 : import 包名.类名; 位置: 类的上面,package信息下面 3.模糊匹配 模糊匹配当前报下要使用的所有类型 只会降低编译效率,不会降低运行效率 4.静态导入 import static 导入一个类型中的静态内容 注意: 以后项目中需要先定义包后定义类型
2.6.3 package、import 测试用例
package com.yjxxt.oop;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
import static java.lang.Math.PI;
import static java.lang.Math.round;
public class Class01_Package {
public static void main(String[] args) {
java.util.Scanner sc = new java.util.Scanner(System.in);
Scanner sc2 = new Scanner(System.in);
Random ran = new Random();
ArrayList list = new ArrayList();
System.out.println(PI);
System.out.println(PI);
System.out.println(PI);
System.out.println(PI);
System.out.println(round(1.4));
System.out.println(round(1.4));
System.out.println(round(1.4));
}
}
2.7 封装
2.7.1 private的使用及分析
2.7.2 private测试用例
package com.yjxxt.oop;
public class Class01_Private {
public static void main(String[] args) {
Person p = new Person();
p.setName("小徐");
p.setAge(19);
p.info();
System.out.println(p.getAge());
}
}
class Person{
private int age;
private String name;
public void setAge(int ane){
this.age=age;
}
public int getAge(){
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public Person(){}//JavaBean规范：至少要写一个构造器
public void info(){
System.out.println(name+"--->"+age);
}
}
2.8 继承
2.8.1 extends使用及分析
2.8.2 extends测试用例
public class Class_Extends01 {
public static void main(String[] args) {
Cat cat=new Cat();
cat.name="JAVA";
cat.age=2;
cat.EatFish();
cat.run();
Dog dog=new Dog();
dog.name="大数据";
dog.age=3;
dog.EatMeat();
dog.run();
}
}
//父类
class Animal{
static int age;
String name;
public void run(){
System.out.println("跑得飞快");
}
}
//子类
class Cat extends Animal{
public Cat(){}
public void EatFish(){
System.out.println(age+"岁的"+name+"正在吃鱼");
}
}
//子类
class Dog extends Animal{
public Dog(){}
public void EatMeat(){
System.out.println(age+"岁的"+name+"正在吃肉");
}
}
2.8.3 modifier 权限修饰符
权限修饰符 : 访问权限修饰符 本类 同包类 不同包类下的子类 不同包下的其他类 public 公共的 √ √ √ √ protected 受保护的 √ √ √ default 默认的 √ √ private 私有的 √ 成员修饰符,只能修饰成员不能修饰局部的 能够修饰类的: public default 父类中被protected修饰的成员,在不同包下的子类中通过继承关系可以使用 常用的: public private
2.8.4 modifier测试用例
public class Class_Modifier02 {
private String testPrivate = "private";
String testDefault = "default";
protected String testProtected = "protected";
public String testPublic = "public";
public static void main(String[] args) {
}
//本类
public void test(){
System.out.println(testPrivate);
System.out.println(testDefault);
System.out.println(testProtected);
System.out.println(testPublic);
}
}
//同包类
class Demo{
public static void main(String[] args) {
Class_Modifier02 cm = new Class_Modifier02();
System.out.println(cm.testPublic);
System.out.println(cm.testProtected);
System.out.println(cm.testDefault);
// System.out.println(cm.testPrivate);
}
}
2.8.5 super关键字
super 与 this 之间的区别: 常见的简答题 this : 指代当前new的对象 1)能够使用在构造器的首行调用本类中的其他构造器 this(参数) 2)区分同名的局部与成员问题 super : 指代父类对象 1)能够在子类构造器的首行调用父类的指定构造器 super(参数) 如果没有显示调用父类的指定构造器,默认调用父类空构造 在 子类构造器的首行不能同时显示定义this()与super() 2) 区分子类与父类同名成员问题 默认就近原则,有局部找局部,没有局部找子类,都没有顺着继承体系到父类中找成员 如果想要找子类this.调用子类成员,但是如果没有局部与成员同名问题,this.可以省略 如果想要找父类super.调用父类成员,如果没有子类与父类与局部同名问题,super.可以省略 创建子类对象,会创建父类对象后创建子类对象--> 先父类后子类 静态内容中不能使用this与super
2.8.6 super测试用例
public class Class_Super03 {
public static void main(String[] args) {
Zi zi=new Zi(2);
System.out.println(zi.i);
zi.test();
}
}
class FU{
int i;
int j;
String str = "父类";
public FU(){
System.out.println("父类空构造");
}
public FU(int i){
System.out.println("父类一个参数的构造");
}
public FU(int i,int j){
System.out.println("父类两个参数的构造");
}
}
class Zi extends FU {
String str = "子类";
public Zi() {
System.out.println("子类空构造");
}
public Zi(int i) {
super(i);
System.out.println("子类一个参数构造");
}
void test(){
String str= "局部str";
System.out.println(str); //局部就近原则
System.out.println(this.str); //子类成员
System.out.println(super.str); //父类成员str
}
}
2.8.7 Override 重写
重写 与 重载 : 都是方法的特性 重载: 1.同一个类中的多个方法 2.方法名相同 3.方法签名(参数列表不同) 重写 : 1.不同的两个类 2.继承|实现 3.方法签名相同 重写前提: 子类对从父类中继承的某功能,功能满意,功能的实现不满意,这个时候可以在子类中对于这个功能进行重写,重新实现 子类中一旦对父类中的某个功能进行重写,在调用时候回对父类的功能进行屏蔽,调用子类中重写的方法 子类对象在调用的时候,子类有重写调用子类的,子类么有重写,调用父类 不能被重写的方法: 被private修饰的方法不能被重写,被private修饰的成员可以被继承,但是无权限访问 被final修饰的方法不能被重写 被static修饰的方法不能被重写 如果子类中存在与父类静态方法同名的方法,要求子类中的同名方法也为static才可 方法签名: 是方法的唯一标识 方法名+参数列表
2.8.7.1 检查是否为重写的方法
1.在行号的后面存在O重写标识 2.@Override 强制检测方法为重写方法
2.8.7.2 重写的满足条件
重写的满足的三个细节条件: == 方法签名 <= 返回值类型 如果返回值类型为基本数据类型|void,要求完全相等 如果返回值类型为引用数据类型 : 要求子类中的重写方法返回值类型<=父类中被重写方法的返回值类型 >= 权限修饰符 子类中重写方法的权限修饰符>=父类中被重写方法的权限修饰符
2.8.8 Override测试用例
package com.yjxxt.oop01;
public class Class_Override04 {
public static void main(String[] args) {
SiCong siCong = new SiCong();
siCong.words();
new JianLin().words();
}
}
class JianLin{
String name = "健林";
static SiCong words(){
System.out.println("先定一个小目标,挣它一个亿!!!");
return null;
}
}
class SiCong extends JianLin{
String name = "思聪";
public static SiCong words() {
System.out.println("我不在乎我的朋友有钱没钱,反正没有我有钱...");
return null;
}
}
2.8.9 final修饰符
2.8.10 final测试用例
public class Class_Final05 {
static final Person p=new Person();
static final int I=0;
static final String NAME="";
static final int AGE=0;
public static void main(String[] args) {
//1) P = new Person();报错
p.age++;
System.out.println(p.age);
}
}
class Person{
String name;
int age;
}
2.8.11 Object
Object 老祖宗 java.lang.Object
是java中所有类的父类
一个类如果没有显示的继承其他父类,就会默认的继承自Object
java中所有类都会显示或者隐式的继承自Object
Object类中定义的成员是所有子类,子类对象都可以使用的(不考虑权限修饰符问题)
Object类中常用的方法:
toString : 返回对象的字符串表现形式
在打印一个对象的引用时,默认输出为当前对象的toString方法的返回值
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
Object类中toString默认返回对象的包名.类名@十六进制地址值
在业务需求下,我们想要输出对象的基本信息(成员变量的值)--> 在子类中重写从父类中继承的toString,子类对象调用的时候回调用重写后的方法
equals : 比较两个对象是否相等
== : 比较是否相等
比较基本数据类型数据值是否相等
比较引用数据类型的地址值是否相等
Object类中的equals的实现: 默认比较对象的地址值
public boolean equals(Object obj) {
return (this == obj);
}
子类中重写equals方法,实现比较对象内容(成员变量的值)非地址值
问: == 与 equals 之间的区别
==可以比较基本数据类型|引用数据类型,比对象地址
equals默认Object类中比较对象地址,因为内部通过==实现比较
可以通过在子类中重写equals实现比较对象内容
javabean规范:
1.类是公共的
2.至少提供一个空构造
3.私有的属性
4.公共的访问方式
5.重写toString与equals方法
2.8.12 Object测试用例
package com.yjxxt.oop01;
public class Class_Object06 {
public static void main(String[] args) {
System.out.println(new Class_Override04());
Cat1 cat1=new Cat1("java","橘猫","黄色");
Cat1 cat2=new Cat1("java","橘猫","黄色");
System.out.println(cat1==cat2);//比较地址
System.out.println(cat1);
System.out.println(cat2);
System.out.println(cat1.equals(cat2));
}
}
class Cat1 {
String name;
String type;
String color;
public Cat1(String name, String type, String color) {
this.name = name;
this.type = type;
this.color = color;
}
@Override
public String toString() {
return this.name + "--->" + type + "-->" + color;
}
//重写equals
public boolean equals(Object obj) {
//第一个对象: this
//第一个对象: obj
if (this == obj) {
return true;
}
//判断参数引用是否指向Cat类型对象,是返回true,不是返回false
if (obj instanceof Cat1) {
//多态 向下转型
Cat1 objCat = (Cat1) obj;
//字符串比较是否相等,需要通过equals比较字符串的内容
if ((this.name).equals(objCat.name) && (this.type).equals(objCat.type) && (this.color).equals(objCat.color));
return true;
}
return false;
}
}
2.9 多态
面向对象的特性---> 多态 : 一种事物的多种形态|多种表现形式 ,行为多态 多态的表现形式:: 父类的引用指向子类类型的对象 多态的前提: 继承|实现 多态调用: 调用子类中重写的方法 只能调用父类中存在的成员,对子类新增内容不可见 注意: 正常的情况都应该为对应类型的数据赋值给对应类型的变量,除了当前满足多态时候,才能够实现对应类型的数据赋值给了其他类型的引用 要求其他类型必须为对象的父类类型 多态调用成员的特点: 成员变量: --> 不存在多态 编译运行看父类 编译运行看左边 编译运行看类型 成员方法: --> 行为才有多态 编译看父类,运行 编译看类型 编译看左边 多态如果不配合方法的重写,多态没有意义 父类引用指向不同的子类对象,当子类中存在重写,对功能实现方式可能不同,这是行为多态的体现,同一个功能的不同实现方式
2.9.1 多态的使用及测试用例
public class Class001_Poly {
public static void main(String[] args) {
//对应类型的数据赋值给对应类型的变量
Person p = new Person();
Student s = new Student();
//多态
Person p2 = new Teacher();
p2.test();
}
}
class Person{
String name = "Person";
public void test(){
System.out.println("Person");
}
}
class Student extends Person{
//String name = "Student";
public void test(){
System.out.println("Student");
}
}
class Teacher extends Person{
public void test(){
System.out.println("Teacher");
}
}
2.10 快捷键的使用
package com.yjxxt.entity;
import java.util.Objects;
public class User {
private int id;
private String username;
private String password;
//构造器
//空构造 : alt+insert->constructor-->enter-->tab切换选中select none ->enter
public User() {
}
//带参构造 : alt+insert->constructor-->enter-->按住shift多选 ->enter
public User(int id, String username, String password) {
this.id = id;
this.username = username;
this.password = password;
}
//设置器与访问器
//快捷键 : alt+insert ->setter and getter -->enter --> 按住shift多选字段 ->enter
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
//toString
//alt+insert->toString->enter->enter
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + ''' +
", password='" + password + ''' +
'}';
}
//equals
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return id == user.id &&
Objects.equals(username, user.username) &&
Objects.equals(password, user.password);
}
}
