5.创建对象内存分析
//创建一个宠物类
package com.study.opp;
public class Pet {
String name;
int age;
//无参构造
public void shout(){
System.out.println("叫了一声!");
}
}
//创建一个application类
package com.study.opp;
public class Application {
public static void main(String[] args) {
Pet dog = new Pet();
dog.name="旺财";
dog.age=3;
dog.shout();
System.out.println(dog.age);
System.out.println(dog.name);
}
}
//上面两个运行之前都存在内存里的方法区中
//运行过程
//1.首先运行到applicatin里的main()方法,main()进入栈中
//2.main()方法在new pet类时,Pet类生成了一个dog引用变量名(类似与地址)加载到了栈区,真正的dog对象存放在堆区中
//对于静态方法区来说,static:和类一起加载,可以直接创建对象到堆区,不需要new
6.简单小结类与对象
1.类与对象
类是一个模板:抽象,对象是一个实例
2.方法
定义、调用。
3.对象的引用
引用类型:基本类型(8)
对象是通过引用来操作的。(由栈指向堆的地址)
4.属性:字段Field 成员变量
默认初始化:
数字:0 0.0
char:u0000
boolea:false
引用:null
修饰符 属性类型 属性名=属性值!
5.对象的创建和使用
- 必须使用new关键字创造对象,构造器 Person zhengxu= new Preson;
- 对象的属性 zhengxu.name
- 对象的方法 zhengxu.sleep
6.类:
静态的属性 属性
动态的属性 方法
7.封装
程序设计要追求“高内聚,低耦合,高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
封装(数据的隐藏):通常,应进制直接访问一个对象中数据的实际表示,而应该通过接口来访问,这称为信息隐藏。
记住这句话就够了:属性私有,get/set
//学生类
package com.study.opp.demo03;
public class Student {
//属性私有
private String name; //名字
private int id; //名字
private char sex; //性别
private int age; //年龄
//提供一些可以操作这个属性的方法
//提供一些public的get、set方法
//get 获得这个数据
public String getName(){
return name;
}
//给这个数据设置值
public void setName(String name){
this.name=name;
}
//alt+insert可以自动生成get和set!!!!!!!!!!!!!!!!!!1
public int getId() {
return id;
}
public char getSex() {
return sex;
}
public void setId(int id) {
this.id = id;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>0&&age<120){
this.age = age;
}else { //不合法就输出3岁
this.age=3;
}
}
}
//=================================
package com.study.opp.demo03;
/*
1.提高程序的安全性,保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加了
*/
public class application {
public static void main(String[] args) {
Student s1=new Student();
//s1.name;//报红,无法直接调用
//通过set和get来设置和获取数据
s1.setName("郑旭");
System.out.println(s1.getName());
s1.setAge(999);//不合法的,可以用set来规避
System.out.println(s1.getAge());
}
}
8.继承
继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模。
extends的意思是”扩展“。子类是父类的扩展。
JAVA中只有单继承,没有多继承。(c++就有)
继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,用关键字extends来表示。子类和父类之间,从意义上讲应该具有"is a"的关系。
object类
super:访问父类的属性和方法 this:访问本类的属性和方法
//=========新建一个Person类=========//
package com.study.opp.demo04;
//在java中都默认直接或间接继承object这个类!!!!
//Person 人:基类 父类
public class Person {
//public
//protected
//default
//private
private int money; //子类不能用super使用父类私有的属性和方法
public int getMoney() {
return money;
}
protected String name="小臭";
public void setMoney(int money) {
this.money = money;
}
public void say(){
System.out.println("说了一句话");
}
//父类无参构造
public Person(){
System.out.println("Person无参构造执行了");
}
}
//=========新建一个Student类=========//
package com.study.opp.demo04;
//学生 is 人:派生类 子类
//继承了父类,就会拥有父类的所有方法
public class Student extends Person{
private String name="小胖";
public void test(String name){
System.out.println(name); //传递的name
System.out.println(this.name); //本类的name:"小胖"
System.out.println(super.name); //父类的name:"小臭"
}
//子类无参构造
public void Student(){
//隐藏代码:调用了父类的无参构造器:super();
super();//调用父类的构造器必须写在第一行,不写也行,默认存在
System.out.println("Student无参构造执行了");
}
}
//=========新建一个Teacher类=========//
package com.study.opp.demo04;
//老师 is 人:派生类 子类
public class Teacher extends Person {
}
//=============具体操作============//
package com.study.opp.demo04;
public class Application {
public static void main(String[] args) {
Student student = new Student();//输出:Person无参构造执行了
// Student无参构造执行了
student.say();//学生类里面没有方法,但因为继承了父类,所以拥有了父类的所有方法
student.test("嘀嘀嘀");
}
}
9.super详解
super注意点:
1.super调用父类的构造方法,必须在构造方法的第一行
2.super必须只能出现在子类的方法或者构造中!
3.super和this不能同时调用构造方法!
VS this:
代表的对象不同:
this:本身调用者这个对象
super:代表父类对象的应用
前提:
this:没有继承也可以使用
super:只有在继承条件下才能使用
构造方法:
this():本类的构造
super():父类的构造!
10.方法重写
重写:需要有继承关系,子类重写父类的方法!
1.方法名必须相同
2.参数列表必须相同
3.修饰符:范围可扩大: private<protected<default<private
4.抛出的异常:范围被缩小,但不能扩大:ClassNotFoundException—>Exception(大)
重写:子类的方法和父类必须一致:方法体不同!
快捷键:alt+insert:override
为什么需要重写?
1.父类的功能,子类不一定需要,或者不一定满足
父类和子类都是静态方法(static)的重写:方法的调用只和左边定义的数据类型有关
//父类
package com.study.opp.demo05;
//重写都是方法的重写,和属性无关
public class A {
public static void test(){
System.out.println("A=>test()");
}
}
//子类
package com.study.opp.demo05;
public class B extends A{
public static void test(){
System.out.println("B=>test()");
}
}
//应用
package com.study.opp.demo05;
public class Application {
public static void main(String[] args) {
//方法的调用只和左边定义的数据类型有关!!!!!!
B b = new B();
b.test(); //B=>test()
//父类的引用指向了子类
A a=new B();
a.test(); //A=>test()
}
}
父类和子类都是非静态方法(无static)的重写:子类能重写父类的方法,和右边定义的数据类型有关
//父类
package com.study.opp.demo05;
//重写都是方法的重写,和属性无关
public class A {
public static void test(){
System.out.println("A=>test()");
}
}
//子类
package com.study.opp.demo05;
public class B extends A{
@Override
//重写 快捷键alt+insert
public void test() {
System.out.println("B=>TEST()");
}
}
//应用
package com.study.opp.demo05;
public class Application {
public static void main(String[] args) {
B b = new B();
b.test(); //B=>test()
//父类的引用指向了子类
A a=new B(); //子类重写了父类的方法
a.test(); //B=>test()
}
}