day8_自我总结
一、回顾
1.idea debug调试
A.设置断点
B.使用debug运行
C.观察代码的执行 以及变量的变化
D.发现问题 解决问题
2.面向对象
面向过程思想:注重于过程 注重于步骤 每一步都是亲力亲为(员工)
面向对象思想 注重于解决问题的主体 注重于对象 不注重于步骤(老板) 偷懒
面向对象思想与面向过程思想是相辅相成
面向对象三大特征: 封装 继承 多态.....
3.类:是一组属性与行为的集合
属性:用于描述事物的特征
行为:用于描述事物的执行动作
4.对象: 类的具体的表现 对象肯定具有类的属性与行为
5.关系: 类是对象的抽象 对象是类的具体表现
6.定义类:
访问修饰符 class 类名{
属性 ==>成员变量
方法 ==>成员方法
}
7.实例化对象
语法: 类名 对象名 = new 类名();
访问成员变量
赋值 对象名.属性名
取值 对象名.属性
访问成员方法
对象名.方法名(参数列表)
8.一个对象创建的内存图
9.两个引用指向同一个堆内存图
10.引用数据类型作为方法的参数
11.匿名对象
语法: new 类名()
使用场景:
A.使用匿名对象调用方法 只调用一次
B.作为方法的实际的参数
C.作为方法的返回值
二、成员变量与局部变量比较
A.定义的位置不同
成员变量定义在类中方法外 局部变量是定义在方法中
B.生命周期不同
成员变量随着对象的加载而加载 随着对象的消失而消失
局部变量随着方法的调用而加载 随着方法的结束而结束
C.存的位置不同
成员变量是存在堆内存中 局部变量是存在栈内存中
D.是否有默认值
局部变量没有默认值 局部变量必须先赋值 才能使用
成员变量是有默认值
整数类型 0 小数类型0.0 字符类型'\u0000' 布尔类型false 引用数据类型 null
三、封装
1. 对属性进行封装 使用关键字 private
a.关键字: private 私有 私人
b.修饰成员 类 方法 变量 ......
c.使用private进行修饰 只能本类进行访问
2. 方案:
问题:
使用private修饰的成员 只能本类进行访问
解决:
提供两个对外访问方法 setxxx() getxxx() ==>xxx 表示的是属性的名称
setxxx() ==>用于来设置值
getxxx()==> 用于来获取值
3. 方案
问题:方法的参数名与成员变量的名称相同 导致成员变量赋值失败
原因:
变量访问是离声明变量最近的位置
在方法中 局部变量优先级大于成员变量 ==>优先访问局部变量
解决:
使用关键字 this 表示当前对象的引用==>就是当前对象
this.变量名==>访问的是成员变量
this.方法名==>访问的是成员方法
this()==>访问是构造方法
4. 快捷键
alt +insert
代码-01
package com.qf.test04;
public class Student {
private String name;
private int age;
//设置值
public void setName(String n) {
name = n;
}
//获取值
public String getName() {
return name;
}
public void setAge(int a) {
age =a;
}
public int getAge(){
return age;
}
}
代码-01
package com.qf.test04;
public class Test01 {
public static void main(String[] args) {
//实例化对象
Student boduo = new Student();
//给成员变量赋值
// boduo.name="波多老师";
//调用set方法进行赋值
boduo.setName("小泽老师");
System.out.println(boduo.getName());
//boduo.age=18;
boduo.setAge(20);
System.out.println(boduo.getAge());
}
}
代码-02
package com.qf.test04;
public class Student {
private String name;
private int age;
//设置值
public void setName(String name) {
this.name = name;
}
//获取值
public String getName() {
return name;
}
public void setAge(int age) {
if (age < 0 || age >120){
this.age=18;
}else {
this.age =age;
}
}
public int getAge(){
return age;
}
}
代码-02
package com.qf.test04;
public class Test01 {
public static void main(String[] args) {
//实例化对象
Student boduo = new Student();
//给成员变量赋值
// boduo.name="波多老师";
//调用set方法进行赋值
boduo.setName("小泽老师");
System.out.println(boduo.getName());
//boduo.age=18;
boduo.setAge(10);
System.out.println(boduo.getAge());
}
}
四、构造方法
-
作用:
a.构造方法用于来实例化对象
b.构造方法用于 接下来能够给成员变量赋值的操作
c.所有实例化对象 都要执行构造方法（即：在实例化一个对象的时候，其会默认直接执行 方法中存在的无参构造） -
分类:
a.无参构造
b.有参构造 -
语法:
访问修饰符 类名(参数列表) { //给成员变量赋值 } -
例子:
public Student(){ } -
说明:
A.构造方法的方法名必须是类名
B.构造方法是可以使用return; 用于结束构造方法 但不能具体return返回具体的数据
C.构造方法不能自身进行调用 必须由jvm来进行调用 -
注意点:
A.在一个类中 如果不提供任何的构造方式 系统默认会提供一个无参构造方法
B.在一个类中 如果提供了（存在）任何的构造方法 系统则不会提供默认的无参构造方法
C.构造方法是可以重载的
D.在实际开发中 一般会提供两种构造方法 一种是有参构造 一种无参构造 -
快捷键 alt + insert
-
set方法与构造方法比较
a.相同点:都可以用于来给成员变量赋值
b.不同点:
构造方法只能在创建对象的时候 给成员变量赋值一次
set方法可以多次给成员变量赋值
五、案例
step01 需求:定义一个企鹅类 属性:名称 性别 爱心值 健康值 方法: 打印对象的属性值
实例化5个企鹅对象 通过键盘录入信息 将企鹅对象保存到数组 并且打印企鹅的信息(get方法获取)
通过构造方法给属性赋值
step02 分析
A.定义一个企鹅类
B.定义一个数组 数组类型 企鹅类
C.使用键盘录入企鹅对象的信息 将企鹅对象保存数组中
D.使用循环遍历 数组 获取属性值
step03 代码-定义企鹅类
package com.qf.test06;
public class Penguin {
//私有的属性
private String name;
private String sex;
private int health;
private int love;
//提供两个构造方法 有参 无参构造
public Penguin(){}
public Penguin(String name,String sex,int health,int love){
this.name=name;
this.sex=sex;
this.health=health;
this.love=love;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
//定义一个方法打印属性值
public void print(){
System.out.println(name+"\t"+sex+"\t"+health+"\t"+love+"\t");
}
}
step04 -代码-测试类
package com.qf.test06;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
//实例化Scanner
Scanner input = new Scanner(System.in);
//定义一个数组
Penguin [] penguins = new Penguin[2];
//使用循环给对象的属性进行赋值
for (int i=0;i<penguins.length;i++) {
System.out.println("请输入企鹅的名称");
String name =input.next();
System.out.println("请输入企鹅性别");
String sex = input.next();
System.out.println("请输入企鹅健康值");
int health = input.nextInt();
System.out.println("请输入企鹅的爱心值");
int love = input.nextInt();
//实例化对象并且给成员变量赋值
Penguin p = new Penguin(name,sex,health,love);
//将对象存入的数组
penguins[i] =p;
}
//使用循环遍历 获取数组中每一个对象
for (int i=0;i<penguins.length;i++) {
Penguin p =penguins[i];
//System.out.println(p.getName()+"\t"+p.getSex()+"\t"+p.getHealth()+"\t"+p.getLove());
p.print();
}
}
}
六、静态
6.1 概念
1.静态的关键字:static
2.修饰的成员
a.类
b.方法
c.变量
3.好处:
没有静态之前:
多个对象相同的属性值的时候 需要开辟多个空间开进行存储 浪费内存空间 修改数据比较麻烦
有静态之后:
多个对象相同的属性值 只需要在方法区中静态区间开辟一块空间 实现所有对象共享 节省内存空间
修改数据比较方便
没有静态之前
有静态之后
6.2 静态变量
1.语法: static 数据类型 变量名
2.静态变量优先与对象先进行加载
3.静态变量是存在方法区中的静态区间中
4.静态变量的访问方式
a.通过类名来进行访问 语法: 类名.静态变量名称 例子: Actor.country 提倡
b.通过对象名来进行访问 语法: 对象名.静态变量的名称 例子: a1.country 不提倡使用
5.静态变量所属类变量 随着类的加载而加载 静态变量不容易被gc进行回收(最后被回收)
6.3 静态方法
1.语法:
访问修饰符 static 返回值类型 方法名称(参数列表) {
方法体;
return 返回值;
}
2.例子:
public static void showInfo(){}
3.注意点:
A.静态的方法不能访问非静态的变量
原因: 静态资源优先与对象存在
B.静态方法不能调用非静态的方法
原因:与上面同理
C.静态方法不能访问this关键
原因:与上面同理
总结: 静态方法不能访问非静态的资源
6.4 静态变量与成员变量的比较
1.所属不同
静态变量属于类变量 成员变量属性对象变量
2.存储的位置不同
静态变量是存在方法区中静态区间中 成员变量是存在堆内存中
3.生命周期不同
A.静态的变量是随着类的加载而加载 最后被gc进行回收
B.成员变量是随着对象的加载而加载 随着对象的销毁而销毁
4.访问的方式不同
A.静态变量调用方式 a.直接通过类名来进行访问(推荐) b.通过对象名来进行访问
B.成员变量的调用方式 只能通过对象名来进行访问
七、继承
7.1继承概念
1.继承中至少有两个类 一个是父类 一个是子类
2.继承关键字 extends
3.继承:就是共性的抽取
4.满足is a 的关系才能使用继承 我是你爸爸 就可以使用继承
5.子类可以获取父类的资源 但是父类不能获取子类的资源
step01 -定义一个类员工类
package com.qf.test08;
public class Emp {
String name;
int age;
}
step02 定义老师类
package com.qf.test08;
public class Teacher extends Emp {
public void work(){
System.out.println("授课......");
}
}
step03 定义类-助教类
package com.qf.test08;
public class Assistant extends Emp {
public void work(){
System.out.println("辅导..........");
}
}
step04 -测试类
package com.qf.test08;
public class Test {
public static void main(String[] args) {
//实例化老师类
Teacher t1 = new Teacher();
t1.name="小野老师";
t1.age=18;
System.out.println(t1.name);
System.out.println(t1.age);
//实例化助教类
Assistant as = new Assistant();
as.name="吴荣俊";
as.age=20;
System.out.println(as.name);
System.out.println(as.age);
//实例化父类对象
Emp e = new Emp();
}
}
7.2 继承的注意点
1.子类不能继承到父类私有(private)的资源
原因:使用private修饰的资源 只能本类进行访问
2.子类不能继承到父类的构造方法
子类不能继承到父类的构造方法 但是可以调用父类的构造方法 通过关键字super
访问父类的无参构造 super()
访问父类的有参构造 super(参数列表)
7.3 java单继承问题
1.在java中 一个类只能有一个直接的父类(亲爸爸) 但是可以有间接的父类(爷爷类)
java只支持单继承 不支持多继承 但是支持多层继承
2.如果一个类没有继承任何类 那么这个类默认继承Object Object类是所有的类的直接爸爸或者是间接爸爸
3.想象成一叉数
7.4 继承中访问成员变量的特点
1.特点:
优先访问子类的成员变量 如果子类没有 则向上进行查找 一直查找到Object类 如果Objet类都没有则报错
step01 -代码-父类
package com.qf.test09;
public class Fu extends Object{
int numFu=100;
int num=200;
}
step02 -代码-子类
package com.qf.test09;
public class Zi extends Fu {
int numZi =300;
// int num =400;
}
step03-代码-测试类
package com.qf.test09;
public class Test {
public static void main(String[] args) {
//实例化子类对象
Zi z = new Zi();
System.out.println(z.num);
//一直向上进行查找 如果查找到Object 没有 则报错
// System.out.println(z.kk);
}
}
7.5 this与super
1.this 与super
this ==> 表示的是当前对象的引用 super==>当前对象父类对象的引用
2.访问成员变量
this 既可以获取自身的成员变量 也可以获取父类的成员变量
super只能获取父类的成员变量
3.访问成员方法
this 既可以获取自身的成员方法 也可以获取父类的成员方法
super 只能获取父类的成员方法
4.访问构造方法
this() ==>表示调用自身的无参构造方法 this(参数)==>表示调用自身的有参构造方法
super()==>表示调用父类的无参构造方法 super(参数)==>表示调用父类的有参的构造方法
step01 父类
package com.qf.test10;
public class Fu {
int num =10;
public void show(){
System.out.println("我是父类的方法");
}
}
step02 子类
package com.qf.test10;
public class Zi extends Fu {
int num =20;
public void show(){
//调用父类的show方法
super.show();
System.out.println("我是子类的show方法");
}
public void showInfo(int num){
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
step03 测试类
package com.qf.test10;
public class Test {
public static void main(String[] args) {
//实例化子类对象
Zi z = new Zi();
z.show();
z.showInfo(30);
}
}
浙公网安备 33010602011771号