Static
/*
如果一个成员变量使用了static关键字,那么这个变量不再属于对象自己,而是属于所在的类。多个对象共享同一份数据。
*/
public class Demo01StaticField {
public static void main(String[] args) {
Student two = new Student("黄蓉", 16);
two.room = "101教室";
System.out.println("姓名:" + two.getName()
+ ",年龄:" + two.getAge() + ",教室:" + two.room
+ ",学号:" + two.getId());
Student one = new Student("郭靖", 19);
System.out.println("姓名:" + one.getName()
+ ",年龄:" + one.getAge() + ",教室:" + one.room
+ ",学号:" + one.getId());
}
}
===================
private int id; // 学号
private String name; // 姓名
private int age; // 年龄
static String room; // 所在教室
private static int idCounter = 0; // 学号计数器,每当new了一个新对象的时候,计数器++
public Student() {
this.id = ++idCounter;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
this.id = ++idCounter;
}
/*
一旦使用static修饰成员方法,那么这就成为了静态方法。静态方法不属于对象,而是属于类的。
如果没有static关键字,那么必须首先创建对象,然后通过对象才能使用它。
如果有了static关键字,那么不需要创建对象,直接就能通过类名称来使用它。
无论是成员变量,还是成员方法。如果有了static,都推荐使用类名称进行调用。
静态变量:类名称.静态变量
静态方法:类名称.静态方法()
注意事项:
1. 静态不能直接访问非静态。
原因:因为在内存当中是【先】有的静态内容,【后】有的非静态内容。
“先人不知道后人,但是后人知道先人。”
2. 静态方法当中不能用this。
原因:this代表当前对象,通过谁调用的方法,谁就是当前对象。
*/
public class Demo02StaticMethod {
public static void main(String[] args) {
MyClass obj = new MyClass(); // 首先创建对象
// 然后才能使用没有static关键字的内容
obj.method();
// 对于静态方法来说,可以通过对象名进行调用,也可以直接通过类名称来调用。
obj.methodStatic(); // 正确,不推荐,这种写法在编译之后也会被javac翻译成为“类名称.静态方法名”
MyClass.methodStatic(); // 正确,推荐
// 对于本来当中的静态方法,可以省略类名称
myMethod();
Demo02StaticMethod.myMethod(); // 完全等效
}
public static void myMethod() {
System.out.println("自己的方法!");
}
}
静态static的内存图
静态代码块
Arrays
/*
java.util.Arrays是一个与数组相关的工具类,里面提供了大量静态方法,用来实现数组常见的操作。
public static String toString(数组):将参数数组变成字符串(按照默认格式:[元素1, 元素2, 元素3...])
public static void sort(数组):按照默认升序(从小到大)对数组的元素进行排序。
备注:
1. 如果是数值,sort默认按照升序从小到大
2. 如果是字符串,sort默认按照字母升序
3. 如果是自定义的类型,那么这个自定义的类需要有Comparable或者Comparator接口的支持。(今后学习)
*/
public class Demo01Arrays {
public static void main(String[] args) {
int[] intArray = {10, 20, 30};
// 将int[]数组按照默认格式变成字符串
String intStr = Arrays.toString(intArray);
System.out.println(intStr); // [10, 20, 30]
int[] array1 = {2, 1, 3, 10, 6};
Arrays.sort(array1);
System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]
String[] array2 = {"bbb", "aaa", "ccc"};
Arrays.sort(array2);
System.out.println(Arrays.toString(array2)); // [aaa, bbb, ccc]
}
}
字符串倒序
Math
练习题
/*
题目:
计算在-10.8到5.9之间,绝对值大于6或者小于2.1的整数有多少个?
分析:
1. 既然已经确定了范围,for循环
2. 起点位置-10.8应该转换成为-10,两种办法:
2.1 可以使用Math.ceil方法,向上(向正方向)取整
2.2 强转成为int,自动舍弃所有小数位
3. 每一个数字都是整数,所以步进表达式应该是num++,这样每次都是+1的。
4. 如何拿到绝对值:Math.abs方法。
5. 一旦发现了一个数字,需要让计数器++进行统计。
备注:如果使用Math.ceil方法,-10.8可以变成-10.0。注意double也是可以进行++的。
*/
public class DemoMathPractise {
public static void main(String[] args) {
int count = 0;
double min = -10.8;
double max = 5.9;
for (int i = (int)min; i <= (int)max; i++) {
int abs = Math.abs(i);
if (abs > 6 || abs < 2.1) {
count++;
}
}
System.out.println(count);
}
}
继承 extends
/*
在继承的关系中,“子类就是一个父类”。也就是说,子类可以被当做父类看待。
例如父类是员工,子类是讲师,那么“讲师就是一个员工”。关系:is-a。
定义父类的格式:(一个普通的类定义)
public class 父类名称 {
// ...
}
定义子类的格式:
public class 子类名称 extends 父类名称 {
// ...
}
*/
public class Demo01Extends {
public static void main(String[] args) {
// 创建了一个子类对象
Teacher teacher = new Teacher();
// Teacher类当中虽然什么都没写,但是会继承来自父类的method方法。
teacher.method();
// 创建另一个子类助教的对象
Assistant assistant = new Assistant();
assistant.method();
}
}
成员变量访问特点
/*
在父子类的继承关系当中,如果成员变量重名,则创建子类对象时,访问有两种方式:
直接通过子类对象访问成员变量:
等号左边是谁,就优先用谁,没有则向上找。
间接通过成员方法访问成员变量:
该方法属于谁,就优先用谁,没有则向上找。
*/
public class Demo01ExtendsField {
public static void main(String[] args) {
Fu fu = new Fu(); // 创建父类对象
System.out.println(fu.numFu); // 只能使用父类的东西,没有任何子类内容
System.out.println("===========");
Zi zi = new Zi();
System.out.println(zi.numFu); // 10
System.out.println(zi.numZi); // 20
System.out.println("===========");
// 等号左边是谁,就优先用谁
System.out.println(zi.num); // 优先子类,200
// System.out.println(zi.abc); // 到处都没有,编译报错!
System.out.println("===========");
// 这个方法是子类的,优先用子类的,没有再向上找
zi.methodZi(); // 200
// 这个方法是在父类当中定义的,
zi.methodFu(); // 100
}
}
类方法中重名的处理
/*
局部变量: 直接写成员变量名
本类的成员变量: this.成员变量名
父类的成员变量: super.成员变量名
*/
public class ExtendsField {
public static void main(String[] args) {
Zi zi = new Zi();
zi.method();
}
}
//===============================
public class Fu {
int num = 30;
public void methodFu(){
int num = 99;
System.out.println(num);
}
}
//===============================
public class Zi extends Fu {
int num = 10;
public void method() {
int num = 20;
System.out.println(num); //20,局部变量
System.out.println(this.num); //10,类成员变量
System.out.println(super.num); //30,父类成员变量
methodFu();
}
}
覆盖重写
/*
在父子类的继承关系当中,创建子类对象,访问成员方法的规则:
创建的对象是谁,就优先用谁,如果没有则向上找。
注意事项:
无论是成员方法还是成员变量,如果没有都是向上找父类,绝对不会向下找子类的。
重写(Override)
概念:在继承关系当中,方法的名称一样,参数列表也一样。
重写(Override):方法的名称一样,参数列表【也一样】。覆盖、覆写。
重载(Overload):方法的名称一样,参数列表【不一样】。
方法的覆盖重写特点:创建的是子类对象,则优先用子类方法。
方法覆盖重写的注意事项:
1. 必须保证父子类之间方法的名称相同,参数列表也相同。
@Override:写在方法前面,用来检测是不是有效的正确覆盖重写。
这个注解就算不写,只要满足要求,也是正确的方法覆盖重写。
2. 子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示:java.lang.Object类是所有类的公共最高父类(祖宗类),java.lang.String就是Object的子类。
3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示:public > protected > (default) > private
备注:(default)不是关键字default,而是什么都不写,留空。
*/
public class Demo01ExtendsMethod {
public static void main(String[] args) {
Zi zi = new Zi();
zi.methodFu();
zi.methodZi();
// 创建的是new了子类对象,所以优先用子类方法
zi.method();
}
}
=============================
public class Fu {
public void methodFu() {
System.out.println("父类方法执行!");
}
void method() {
System.out.println("功能");
System.out.println("父类重名方法执行!");
}
==============================
public class Zi extends Fu {
public void methodZi() {
System.out.println("子类方法执行!");
}
@Override
public void method() {
super.method();
System.out.println("子类重名方法执行!");
}
}
}
/*
继承关系中,父子类构造方法的访问特点
1.子类构造方法中有一个默认隐含的"super()"调用,所以一定是先调用
父类构造
2.可子类构造通过super关键字调用父类重载构造
3.super的父类构造调用,必须是子类构造方法的第一个语句
不能一个子类构造调用多次super构造
总结:
子类必须调用父类构造方法,不写则赠送super();写了则用写的指定的super调用,
super只能有一个,必须是第一个
*/
/*
super关键字的用法有三种:
1. 在子类的成员方法中,访问父类的成员变量
2. 在子类的成员方法中,访问父类的成员方法
3. 在子类的构造方法中,访问父类的构造方法
*/
/*
super关键字用来访问父类内容,而this关键字用来访问本类内容
用法有三种
1.在本类的成员方法中,访问本类的成员变量
2.在本类中的成员方法中,访问本类的另一个成员方法
3.在本类的构造方法中,访问本类的另一个构造方法
在第三种用法当中注意:
A.this(...)调用也必须是构造方法的第一个语句,唯一一个
B.super 和 this 两种构造调用,不能同时使用
*/
public class Zi extends Fu {
int num = 20;
public Zi() {
// super(); //这一行不在赠送
this(123); //本类的无参构造,调用本类的有参构造
// this(1,2); // 错误写法
}
public Zi(int n) {
}
public Zi(int n, int m) {
}
/*
抽象方法:就是加上abstract关键字,然后去掉大括号,直接分号结束
抽象类:抽象方法所在的类,必须是抽象类才行
在class之前写上abstract即可
如何使用抽象类和抽象方法:
1.不能直接创建new抽象类对象
2.必须用一个子类继承抽象父类
3.子类必须覆盖重写抽象父类当中所有的抽象方法
覆盖重写(实现):子类去掉抽象方法的abstract关键字,然后补上方法体
大括号
4.创建子类对象进行使用
*/
public abstract class Animal {
// 这是一个抽象方法,代表吃东西,但是具体吃什么不确定
public abstract void eat();
//普通的成员方法
public void normalMethod(){
}
}
Alt + 回车 -->实现方法 快速填充子类重写方法
public class DemoMain {
public static void main(String[] args) {
DogGolden golden = new DogGolden();
golden.sleep();//呼呼呼...
golden.eat();//吃骨头
}
}
======================================
public abstract class Dog extends Animal {
@Override
public void eat() {
System.out.println("吃骨头");
}
}
======================================
public class DogGolden extends Dog{
@Override
public void sleep() {
System.out.println("呼呼呼...");
}
}
======================================
public class Dog2Ha extends Dog {
@Override
public void sleep() {
System.out.println("偶偶偶...");
}
}
// 主程序
public static void main(String[] args) {
Manager manager = new Manager("群主",99);
Member one = new Member("成员A",0);
Member two = new Member("成员B",0);
Member three = new Member("成员C",0);
manager.show();
one.show();
two.show();
three.show();
System.out.println("===============");
ArrayList<Integer> redList = manager.send(9,6);
one.receive(redList);
two.receive(redList);
three.receive(redList);
manager.show();
one.show();
two.show();
three.show();
}
//User
public class User {
private String name;//姓名
private double money;//余额
public User() {
}
public User(String name, double money) {
this.name = name;
this.money = money;
}
//展示一下当前用户多少钱
public void show(){
System.out.println("我叫"+this.name+",我有" +this.money+"钱");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
}
//群主
public class Manager extends User {
public Manager() {
}
public Manager(String name, double money) {
super(name, money);
}
public ArrayList<Integer> send(int totalMoney, int count) {
//需要一个集合,存储若干个红包的金额
ArrayList<Integer> redList = new ArrayList<>();
//查看余额有多少钱,判断发送金额是否超过余额
double leftMoney = super.getMoney(); //群主当前余额
if (totalMoney > leftMoney) {
System.out.println("余额不足");
return redList;//返回空集合
}
//扣钱,设置余额
super.setMoney(leftMoney - totalMoney);
//发红包,拆分成count份
int avg =totalMoney / count;
int mod =totalMoney % count;//余数
for (int i = 0; i < count-1; i++) {
redList.add(avg);
}
redList.add(avg+mod);
return redList;//返回这个集合
}
}
//成员
public class Member extends User {
public Member(){
}
public Member(String name, double money) {
super(name, money);
}
public void receive(ArrayList<Integer> list){
//从多个红包中抽取一个
int index = new Random().nextInt(list.size());
//根据索引,从集合中删除,并且得到删除的红包
int delta = list.remove(index);
//设置金额
super.setMoney(delta+super.getMoney(););
}
}