java基础-java面向对象01-day08
1. 一个简单的类
认识类
成员变量 类方法
public class Person {
//类的成员变量
int age;
String name;
double height;
double weight;
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public String introduce(){
return "名字："+name+ "年龄："+age+"身高："+height+"体重"+weight
}
}
实例化对象 调用对象的方法
public class Test {
public static void main(String[] args) {
//第一次加载类的时候，会进行类的加载，初始化创建对象的时候，对象的属性没有给赋值，有默认的初始化的值。
Person zs = new Person();
zs.name = "张珊";
zs.age = 19;
zs.height = 188.8;
zs.weight = 75;
//再次创建对象 不会再加载类
Person ls = new Person();
ls.name = "李四";
ls.age = 20;
ls.weight = 80;
ls.height = 188.9;
System.out.println(zs.name);
System.out.println(ls.name);
zs.sleep();
ls.eat();
System.out.println(zs.introduce());
}
}
2. 构造器
无参构造器 有参构造器 什么是this
public class Person {
String name;
int age;
double height;
public Person(){
}
public Person(String name, int age, double height){
//当形式参数与属性名 重名的时候会出现就进原则
//在对象的属性赋值的时候加上this
this.name = name;
this.age = age;
this.height = height;
}
public Person(String a, int b){
name = a;
age = b;
}
public void eat(){
System.out.println("吃饭");
}
}
new一个对象的 过程 以及构造器的注意点
public class Test {
public static void main(String[] args) {
/*
1. new 关键字实际上是在调用一个方法 这个方法叫做构造方法（构造器）
2. 系统会默认分一个构造方法
3. 可以自己显示的编写构造方法
构造方法与普通方法的区别
1. 没有返回值的类型
2. 不能有return语句
3. 名字必须与类的名字一样
构造器的作用：
不是为了创建对象
调用构造器之前对象就已经创建并且属性有初始值
构造器的本质是给对象的属性进行赋值操作
注意点：
1. 一般不会在空构造器里面进行初始化操作，否则所有的对象的属性就一样
2. 需要保证每个类空构造器的存在， 逻辑可以什么都不写，
*/
Person p = new Person();
System.out.println(p.age);
System.out.println(p.name);
System.out.println(p.height);
Person p2 = new Person("张三", 18, 188.9);
System.out.println(p2.age);
System.out.println(p2.name);
System.out.println(p2.height);
}
}
1.一般要保证空构造器的存在，且空构造器不进行属性的赋值操作
2. 一般要进行构造器的重载，在重载构造器中进行属性的赋值操作；
3. 重载构造器之后，如果空构造器忘记写，系统就再也不会分默认的空构造器，new Persion()则会报错
4. 当形式参数与类的属性重名，属性的赋值前加上this来修饰
public class Test2 {
public static void main(String[] args) {
Person p = new Person();
p.age = 19;
p.name = "lili";
p.height = 188.8;
Person p2 = new Person("lili", 19, 180.1);
System.out.println(p2.age);
System.out.println(p2.height);
System.out.println(p2.name);
}
}
3. new对象 内存分析
Person p1 = new Person();
创建对象的过程：
1. 在第一次遇到一个类的时候 需要堆这个类进行加载 只加载一次
2. 创建对象需要在堆中开辟空间
3. 对象的初始化 属性的赋值都是默认值
4. new关键字 会调用构造器 执行构造方法 在构造器中对属性进行重新的赋值
4. this详解
public class Person {
String name;
int age;
double height;
public Person(){
}
public Person(String name, int age, double height){
//当形式参数与属性名 重名的时候会出现就进原则
//在对象的属性赋值的时候加上this
this.name = name;
this.age = age;
this.height = height;
}
public Person(String a, int b){
name = a;
age = b;
}
public void eat(){
System.out.println("吃饭");
}
}
this:
public class Person {
String name;
int age;
double height;
public Person(){
}
public Person(String name, int age, double height){
//当形式参数与属性名 重名的时候会出现就进原则
//在对象的属性赋值的时候加上this
this(name, age); //同一个类中 构造器可以用this调用 但是要写在第一行
this.height = height;
}
public Person(String a, int b){
name = a;
age = b;
}
public void eat(){
System.out.println("吃饭");
}
}
5. static如何详解
public class Test4 {
int id;
int sid;
public static void main(String[] args) {
Test4 t1 = new Test4();
t1.id = 10;
t1.sid = 10;
Test4 t2 = new Test4();
t2.id = 20;
t2.sid = 20;
Test4 t3 = new Test4();
t3.id = 30;
t3.sid = 30;
System.out.println(t1.id);
System.out.println(t2.id);
System.out.println(t3.id);
System.out.println(t1.sid);
System.out.println(t2.sid);
System.out.println(t3.sid);
//System.out.println(Test4.sid);
}
}
sid加上 static 之后
static总结：
- 加载类的时候会将静态的内容也加载到方法区
- 静态域中的内容先于对象的存在
- 静态的内容被所有类的对象共享
- 访问方式 类名.属性名
使用场景：
特定的数据 所有的对象共享
public class JavaLearningStudent {
String name;
int age;
static String school;
public static void main(String[] args) {
JavaLearningStudent.school = "xx大学";
JavaLearningStudent s1 = new JavaLearningStudent();
s1.name = "张三";
s1.age = 19;
JavaLearningStudent s2 = new JavaLearningStudent();
s2.name = "李四";
s2.age = 20;
//s2.school = "new大学";
System.out.println(s2.school);
}
}
属性的分类：
- 类属性
- 对象属性
静态方法：
package com.msb2;
/**
* @Auther: jack.chen
* @Date: 2023/9/8 - 09 - 08 - 21:50
* @Description: com.msb2
* @version: 1.0
*/
public class Demo {
int id;
static int sid;
public void a(){
System.out.println(id);
System.out.println(sid);
System.out.println("----a");
}
static public void b(){
//静态方法中不能访问this
//System.out.println(id); 静态方法不能访问非静态的属性
//a();静态方法不能访问非静态的方法
System.out.println(sid);
System.out.println("----b");
}
public static void main(String[] args) {
Demo d = new Demo();
d.a();
Demo.b(); //静态方法可以用类.方法名 直接调用
b(); //同一个类方法直接调用
}
}
6. 什么是代码块
package com.msb2;
/**
* @Auther: jack.chen
* @Date: 2023/9/8 - 09 - 08 - 22:01
* @Description: com.msb2
* @version: 1.0
*/
public class TestBlock {
int a;
static int sa;
public TestBlock(){
System.out.println("这是空构造器");
}
public TestBlock(int a){
this.a = a;
}
public void a(){
System.out.println("====a");
}
static public void sa(){
System.out.println("===sa");
}
// 这个是静态块
static {
System.out.println("---静态块");
System.out.println(sa); //静态块能够访问静态属性
}
public static void main(String[] args) {
TestBlock t = new TestBlock();
t.a();
sa();
}
}
代码块的执行顺序：
先执行静态块 只在类的加载时候执行一次（实战项目中 创建工厂 数据库的初始化信息放入静态块 用于全局的初始还操作）
再执行构造器
7. import导包
解决重名的问题 找到对应的类
- 包的名字全部小写
- 包一般都是公司域名 倒着写 com.jd com.huawei com.baidu
- 加上模块的名字
com.huawei.aiservice com.huawei.login - 包声明一般在类的第一行
