代码在opp package里面
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IBudrW4d-1647441872631)(C:UsersQiao.yanliDesktopJAVA学习markdown学习流程控制DAY07_1.jpg)]
package oop.Demo;
public class Person {
//一个类什么都不写，也有一个方法就是构造器
//显示的定义构造器
String name;
//构造器的作用：
//实例化初始值，使用new关键字，本质就是调用构造器
public Person(){
//this.name="BX";
}
//有参构造器，一旦定义了有参构造，无参构造必须下显示定义
public Person(String name){
this.name=name;
}
}
//生成构造器的方法：code--generate--constructor
package oop.Demo;
public class Application {
public static void main(String[] args) {
//类：抽象的，实例化
//类实例化后会返回一个自己的对象！
//xiaoming就是student类实例化后的具体实例
Person person=new Person("BX");
System.out.println(person.name);
}
}
栈与堆（方法区）
栈用来存放一些引用以及方法，堆用来存放具体的变量值，
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ESCZoXmy-1647441872633)(C:UsersQiao.yanliDesktopJAVA学习markdown学习流程控制DAY07_2.jpg)]
方法与类小结，很重要[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AeVjh2u5-1647441872634)(C:UsersQiao.yanliDesktopJAVA学习markdown学习流程控制DAY07_3.jpg)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SbTmO4IF-1647441872635)(C:UsersQiao.yanliDesktopJAVA学习markdown学习流程控制DAY07_5.jpg)]
八大基本类型有：整形（int32位 byte8位 short16位 long64位 )、浮点型（double64位 float32位）、字符新（char16位）、布尔型（boolean）
整形默认值为0，浮点型默认值为0.0
四大引用类型有：数组、类、接口、字符串
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tJRvj1sE-1647441872636)(C:UsersQiao.yanliDesktopJAVA学习markdown学习流程控制DAY07_6.jpg)]
（1）基本数据类型传值，对形参的修改不会影响实参;
（2）引用类型传引用，形参和实参指向同一个内存地址（同一个对象），所以对参数的修改会影响到实际的对象；
（3）String, Integer, Double等immutable（不可改变）的类型特殊处理，可以理解为传值，最后的操作不会修改实参对象。
封装[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8ojLqYLd-1647441872637)(C:UsersQiao.yanliDesktopJAVA学习markdown学习流程控制DAY07_7.jpg)]
package oop.Demo;
//提高程序的安全性，保护数据
//隐藏代码的实现细节
//统一接口
//系统可维护增加了
public class Package {
private String name;
private int id;
private char sex;
public String getName(){
return this.name;
}
public void setName(String name){
this.name=name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}
Package s1=new Package();
s1.setId(1823);
System.out.println(s1.getId());
s1.setName("博肖");
System.out.println(s1.getName());
s1.setSex('男');
System.out.println(s1.getSex());
继承
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iNjf398J-1647441872639)(C:UsersQiao.yanliDesktopJAVA学习markdown学习流程控制DAY07_8.jpg)]
当父类被final时不能有子类，即继承人，断子绝孙父类
package oop.Demo;
public class Person extends Object{
//一个类什么都不写，也有一个方法就是构造器
//显示的定义构造器
String name;
public int money=10_0000_0000;
//构造器的作用：
//实例化初始值，使用new关键字，本质就是调用构造器
public Person(){
//this.name="BX";
}
//有参构造器，一旦定义了有参构造，无参构造必须下显示定义
public Person(String name){
this.name=name;
}
}
//生成构造器的方法：code--generate--constructor
子类
package oop.Demo;
//学生类
public class student extends Person {
//属性
int age;
String name;
//方法
public void study(){
System.out.println(this.name+"正在学习");
}
}
子类 继承父类就有父类所有的方法
子类可以用父类中所有public 的东西ctrl+h可以查看继承树
所有的类都直接或者间接继承Object的类
修饰符的优先级
public
protected
default
private
super使用子类
package oop.Demo;
public class Teacher extends Parent {
public Teacher() {
//隐藏代码：调用了父类的无参构造,且必须在子类构造器的第一行
super("调用父类的有参构造");
System.out.println("Teather无参构造执行了");
}
public Teacher(String name) {
this.name = name;
}
private String name="qinjiang";
public void print(){
System.out.println("student");
}
public void test1(){
print();
this.print();
super.print();
}
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
父类
package oop.Demo;
public class Parent {
protected String name="kuanshen";
public Parent(String name) {
this.name = name;
}
public void print(){
System.out.println("Parent");
}
}
super的注意点
1.super 调用父类的构造方法，必须在子类构造方法的第一行
2.super 必须只能出现在子类的方法或者构造器中
3.super和this不能同时调用构造方法
superVSthis
代表的对象不同：
this :本身调用者的这个对象
super:代表父类对象的应用
前提：
没有继承也可以使用
只能在继承时才能使用
构造方法：
this()：调用本类的构造方法
super():调用父类的构造
重写1.需要有继承关系，子类重写父类的方法
2.方法名必须相同
3.参数列表必须相同
4.修饰符：范围可以扩大，不能缩小public>private
5.抛出的异常只能缩小，不能扩大
package oop.Demo;
public class App {
public static void main(String[] args) {
A a=new A();
a.print();
//父类的引用指向了子类
// 静态时：方法的数据类型只与左边有关
B b=new A();
b.print();//调用的是B的方法
//非静态时：子类可以对父类重写，快捷键code-->generate-->override
//此时a和b调用的都是A的方法
//重写时，方法需要是public
}
}
package oop.Demo;
public class B {
public void print(){
System.out.println("打印B");
}
}
package oop.Demo;
public class A extends B {
@Override //重写
public void print() {
System.out.println("打印A");
}
}
多态
A a=new A();
a.print();
//父类的引用指向了子类
// 静态时：方法的数据类型只与左边有关
B b=new A();
b.print();//调用的是B的方法
//父类不能调用子类的独有的方法，如果必须调用，需要强制转换
((A)b).eat();//强制转换，
1.多态指的是方法的多态，与属性无关
2.类型转换会有异常 ClassCastExeption！
3.多态的存在条件，方法可以被重写，以下情况方法不能被重写 ：方法是 1.static 2.final 3.private
instanceof类型转换x instaneof y判断x与y之间是否有父子关系
static关键字详解可以修饰类 ，可以修饰方法，可以修饰属性
package oop.Demo;
public class Demo5 {
private static int age;
private double score;
public static void run(){
// go();静态方法不能调用非静态方法
//静态 方法可以调用静态方法
System.out.println("paoqilai");
}
public void go(){
run();//非静态方法可以调用静态方法
System.out.println("zouqilai");
}
public static void main(String[] args) {
Demo5.age=5;
// Demo5.score=98;出错
Demo5.run();
//Demo5.go();出错
Demo5 demo=new Demo5();
demo.score=98;
demo.go();
}
}
匿名代码块
package oop.Demo;
public class Demo6 {
{//2.匿名代码块
System.out.println("匿名代码块");
}
static{//1.只执行一次
System.out.println("静态代码块");
}
public Demo6() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Demo6 d=new Demo6();//先执行代码块（1.静态代码块，2.匿名代码块），再执行3.构造方法
Demo6 d1=new Demo6();//先执行代码块（1.静态代码块，2.匿名代码块），再执行3.构造方法
}
}
静态导入包
package oop.Demo;
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Demo7 {
public static void main(String[] args) {
// System.out.println(Math.random());
System.out.println(random());
System.out.println(PI);
}
}
