1：创建对象内存图
学习方法：
语法学习：记忆 特点：内容多 基础 乱
oop学习：1 理解概念
2 5 张内存图
创建对象内存图
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ulNY1hHU-1690269531351)(imgs/image-20220902101137054.png)]](https://img-blog.csdnimg.cn/813ab59f38804088a1f5119158803dff.png)
2：static
关键字：修饰符：静态的
public class Demo02Static {
/*static: 修饰符 静态的
*static修饰变量：共享数据
*1 static修饰的变量 不但可以被对象调用 还可以被类名直接调用
*2 static修饰的变量是共享数据 只有一份 一旦更改 所有对象的此属性都被更改
*static修饰方法：
*1 static修饰的方法 不但可以被对象调用 还可以被类名直接调用
*2 static修饰的方法 只能调用static成员 不能调用非static成员
*
*
*类成员：static修饰的成员(成员变量+成员方法) ---属于类的
*实例成员：非static修饰的成员 ---属于对象的
*
*类变量：static修饰的变量----共享数据
*实例变量：非static修饰的变量----只能被当前对象调用
*类方法：static修饰的方法
*实例方法：非static修饰的方法
*
*类加载时：会为本类在内存中定义一个区域 作为静态区域：加载本类的静态成员
*
*什么情况下把一个变量定义为静态变量：数据是共享数据 只有一份 需要一变都变时
*什么情况下把一个方法定义为静态方法：当一个方法不涉及实例成员时 建议定义为静态方法
*
*
*
*
* */
public static void main(String[] args) {
// // TODO Auto-generated method stub
// Student02 s11=new Student02();
// s11.name="韩梅梅1";s11.banJi="java43";s11.ysjLogo="小天鹅";s11.guoJi="中国";
// Student02 s12=new Student02();
// s12.name="韩梅梅2";s12.banJi="java43";s12.ysjLogo="小天鹅";s12.guoJi="中国";
// Student02 s13=new Student02();
// s13.name="韩梅梅3";s13.banJi="java43";s13.ysjLogo="小天鹅";s13.guoJi="中国";
// Student02 s14=new Student02();
// s14.name="韩梅梅4";s14.banJi="java43";s14.ysjLogo="小天鹅";s14.guoJi="中国";
// //每个对象都拥有一套类中定义的只属于的自己的成员：：每个对象都有自己的name,age,banJI和show
// //The static field Student02.guoJi should be accessed in a static way
// Student02.guoJi="中华人民共和国";
// s11.guoJi="中华民国";
// s11.show();
// s12.show();
// s13.show();
// s14.show();
// s11.hehe();
// s11.haha();
Student02.haha();
}
}
class Student02{
static void haha() {
System.out.println("static void haha()");
//hehe();//Cannot make a static reference to the non-static method hehe() from the type Student02
//System.out.println("学生："+name+","+guoJi+","+age+","+banJi+","+ysjLogo);
// Cannot make a static reference to the non-static field banJi
}
String name;
int age;
static String guoJi;
String banJi;
String ysjLogo;
Student02(){}
void show() {
System.out.println("学生："+name+","+guoJi+","+age+","+banJi+","+ysjLogo);
}
void hehe() {
System.out.println("void hehe()");
haha();
System.out.println("学生："+name+","+guoJi+","+age+","+banJi+","+ysjLogo);
}
}
静态内存图
3：私有化封装
public class Demo02Static {
public static void main(String[] args) {
Student02 s11=new Student02();
s11.age=-1;//通过对象直接范围属性 不安全：：：Student02类对属性值的范围无法控制
}
}
class Student02{
int age;
}
- 概念
私有化： 让属性对可信任的类可见 对不可信任的类隐藏
私有化封装：1 属性前面加(范围修饰符)修饰符：private
2 给属性通过getter setter方法
public class Demo03Private {
//私有化： 让属性对可信任的类可见 对不可信任的类隐藏
//1 属性添加范围修饰符private
//2 提供公共的public的get set 方法
// get方法格式： public 属性类型 getXxx();
// set方法格式： public void setXxx(参数列表)
public static void main(String[] args) {
Demo03 d11=new Demo03();
d11.name="呵呵";//:::name对于d1对象来说是可见
//d11.age :::age对于d1对象来说是不可见
d11.setAge(-11);
//d11.show();
System.out.println(d11.name+"::"+d11.getAge());
}
}
class Demo03{
String name;
private int age;
void show() {
System.out.println("name="+name+",age="+age);
}
public static void m1() {
Demo03 d1=new Demo03();
d1.name="呵呵";//:::name对于d1对象来说是可见
d1.age=11; //:::age对于d1对象来说是可见
}
//给age属性赋值
public void setAge(int age) {
if(age<=0 || age> 130) {
return;
}
this.age=age;
}
//获取age属性的值
public int getAge() {
return this.age;
}
}
4： 继承
关键字：extends
概念：当定义一个新类时 如果此新类拥有一个现有的类所有的成员时 可以让此新类从现有的类派生、衍生
理解：类的类继承--类的复用
Class Person{
int age;
String name;
char sex;
void eat(){}
void show(){}
}
class Student extends Person{
float score;
void add(){}
}
class Worker extends Person{
float salary;
void work(){}
}
* 继承概念：定义新类时 如果新类拥有一个现有的类所有的成员时 可以让新类从现有的类 派生、衍生
* 继承关键字：extends
* 子类：新类
* 父类/根类/超类: 现有的类
* 继承特点：1 子类继承了父类的所有成员( 子类中不需要定义 就拥有了父类中定义的所有成员)
* 2 构造方法不能被继承
* 3 私有的成员不能被子类继承
* 4 在子类中可以定义父类没有的成员--子类特有成员
* 5 子类可以重新定义父类已于的成员变量：要求变量名一致即可
* 6 子类可以重新定义父类已于的成员方法：方法声明必须和父类一致
* 子类重新定义父类的成员方法---重写(覆盖)--override
* 原因：父类的成员不能满足子类的需求
* 7 一个类如果没有继承其他类 默认继承Object类
* 8 java只支持类与类的单继承：一个子类只能有一个直接父类
class Person1 extends Object{
int age=30;
String name="呵呵";
char sex='男';
void eat(){}
void show(){
System.out.println(age+":"+name+":"+sex);
}
private int a;
}
class Student1 extends Person1{
String age="ggg";
//int age=1;//重新定义父类已有的成员变量：要求是：属性名一致即可
//重新定义父类已有的成员方法：原因： 父类的成员无法满足子类的需求
// 要求是：方法声明和父类完全相同
void show(){
System.out.println(age+":"+name+":"+sex+":"+score);
}
float score; //子类特有
void add(){} //子类特有
}
class Worker1 extends Person1{
float salary;
void work(){}
}
5： final
final:修饰符：修饰类+普通方法+成员变量+局部变量
: 最终的、不能更改的
public class Demo02Fianl {
/* final:修饰符：修饰类+普通方法+成员变量+局部变量
: 最终的、不能更改的
* final修饰的类 不能被继承
* final修饰的方法 不能被重写
* final修饰的成员变量： 1 没有默认初始值 必须显式赋值 2 不能重复赋值
* final修饰的局部变量： 1 不能重复赋值
*
* final修饰的变量----常量//1 'a' true
* final修饰的变量----命名规范：所有字母大写 单词之间用_分割
*
* final String WO_DE_MING_ZI="xxx";
* 值不能更改的数据：
* 圆周率：某个人的身份证号：作者名字....
* fianl double PI=3.1415926::::1 增加可读性 2 降低出错概率
* */
public static void main(String[] args) {
Demo021 d1=new Demo021();
d1.show();
Demo023 d2=new Demo023();
d2.hai();
Demo024 d3=new Demo024();
d3.hai();
d3.hehe();
}
}
final class Demo021{
int a;
void show() {}
}
class Demo023{
void hehe() {}
final void hai() {}
}
class Demo024 extends Demo023{
void hehe() {//重写
System.out.println("void hehe() ");
}
//final void hai() {}// Cannot override the final method from Demo023
}
class Demo025{
int a;
final int b=1;//The blank final field b may not have been initialized
void test01() {
System.out.println(a+"::"+b);
//b=1;//The final field Demo025.b cannot be assigned
//b++;
final int c=1;
System.out.println(c);
c++;
}
}
//final 类是最终类 不能被继承
//class Demo022 extends Demo021{}//The type Demo022 cannot subclass the final class Demo021
6 ：范围修饰符
范围修饰符：用于指定被修饰者的访问范围的关键字
范围修饰符：三个 四种情况：：：public protected (default) private
public class Demo03FWXSF {
public String publicField="publicFieldValue";
protected String protectedField="protectedFieldValue";
String defaultField="defaultFieldValue";
private String privateField="privateFieldValue";
public static void main(String[] s) {
Demo03FWXSF d1=new Demo03FWXSF();
System.out.println(d1.publicField+":"+d1.protectedField+":"+d1.defaultField+":"+d1.privateField);
}
}
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3R6ffpI1-1690269531352)(imgs/image-20220903145911530.png)]](https://img-blog.csdnimg.cn/c7d1a7c3b8dd44fd92e626e1755d48a9.png)
7：super
super:关键字 父类的 只用在方法体中
this: 关键字 我自己的 只用在方法体中
public class Demo04Super {
/*
* super
* 使用场景1：子类方法中调用父类的成员 通过super.
* 使用场景2： 所有的子类构造方法第一个语句 必须是super(参数列表) 来引用父类的构造方法
* (用与在创建子类对象时 把父类中定义的成员加载进子类对象内存中)
* 默认情况：super() 来调用父类无参数的构造方法
*
* this
* 使用场景1：方法中调用成员 通过this.
* 使用场景2：构造方法之间相互调用通过this(参数列表)
* */
public static void main(String[] args) {
Demo04Zi d1=new Demo04Zi();
d1.show();
}
}
class Demo04Fu{
int a=11;
int b=12;
void hehe() {
System.out.println("fu hehe");
}
void hai() {
System.out.println("fu hai");
}
Demo04Fu(int a){}
}
//implicit super constructor Demo04Fu() is undefined for default constructor. Must define an explicit constructor
class Demo04Zi extends Demo04Fu{
int b=22;//重新定义父类的成员本类
void hai() {//重写父类的方法
System.out.println("zi hai");
}
void show() {
System.out.println("b="+b);//a=11,b=22
hai();//zi hai
System.out.println("super.b="+super.b);//调用父类的成员：super.
super.hai();//调用父类的成员：super.
System.out.println("a="+a+"子类中调用父类成员 前面默认有super."+super.a);
super.hehe();
hehe();
}
Demo04Zi(){
//super();
//System.out.println(11);
super(1);//Constructor call must be the first statement in a constructor
}
Demo04Zi(int c){
super(1);//调用父类有参数的构造方法
}
Demo04Zi(int c,int d){
super(1);
}
}
8：补齐所有的默认
//使用默认的内容 都补齐
class Demo extends Object{ // 1 一个类没有继承其他类 默认继承Object类
int a=0;//2 成员本类默认初始值
int b=0;//2 成员本类默认初始值
void show() {
System.out.println(this.a+":"+this.b); //4 方法中 成员前面默认有this.
return;//3 方法没有返回值 return省略
}
void hai() {
return;//3 方法没有返回值 return省略
}
void hehe() {
return;//3 方法没有返回值 return省略
}
//5 一个类没有构造方法 默认有一个无参数的构造方法
Demo(){
//6 所有的子类构造方法 第一个语句默认是super()来调用父类无参数的构造方法
super();
}
}
class DemoZi extends Demo{
int a=0;//2 成员本类默认初始值
int c=0;//2 成员本类默认初始值
void show() {
System.out.println(a+":"+c); //4 方法中 成员前面默认有this.
System.out.println(super.b); //7 子类方法中 调用父类成员前面默认有super.
this.hai(); //4 方法中 成员前面默认有this.
super.hehe(); //7 子类方法中 调用父类成员前面默认有super.
return;//3 方法没有返回值 return省略
}
void hai() {
return;//3 方法没有返回值 return省略
}
//5 一个类没有构造方法 默认有一个无参数的构造方法
DemoZi(){
//6 所有的子类构造方法 第一个语句默认是super()来调用父类无参数的构造方法
super();
}
}
72
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
