目的与要求
- 掌握Java修饰符
- 掌握Java四大储存域
- 掌握Java匿名内部类
- Java面向接口
Java修饰符
Java语言提供了两类修饰符：
- 访问修饰符
- 非访问修饰符
1、访问修饰符
| 修饰符 | 当前类 | 同一包内 | 子孙类(同一包) | 子孙类(不同包) | 其他包 |
|---|---|---|---|---|---|
| public | Y | Y | Y | Y | Y |
| protected | Y | Y | Y | Y/N（说明） | N |
| 默认 | Y | Y | Y | N | N |
| private | Y | N | N | N | N |
2、非访问修饰符
static静态：
1、静态变量
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
2、静态方法
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。
3、静态代码块
static修饰的代码块具有类级别的优先级，子啊类被加载的时候自动执行
static关键字修饰的静态变量和静态函数使用：类名.变量名；类名.函数名
package com.star.demo11;
public class Student {
private String name;
// 私有静态变量
private static int count;
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public static int getCount() {
return count;
}
public void setName(String name) {
this.name = name;
}
// 静态方法在类的内外都使用【类名.】来调用
public static void setCount(int count) {
// 静态变量在类的内外都使用【类名.】来调用
Student.count = count;
}
}
----------------------------------------------------------------------------
package com.star.demo11;
public class Main {
public static void main(String[] args) {
Student student1 = new Student("张三");
student1.setCount(1);
Student student2 = new Student("李四");
student2.setCount(2);
Student student3 = new Student("王五");
student3.setCount(3);
Student student4 = new Student("麻子");
student4.setCount(4);
//System.out.println("创建学生总数为："+Student.count);
System.out.println("创建学生总数为："+Student.getCount());
System.out.println("创建学生总数为："+student1.getCount());
System.out.println("创建学生总数为："+student2.getCount());
System.out.println("创建学生总数为："+student3.getCount());
System.out.println("创建学生总数为："+student4.getCount());
}
}
final最终
final 表示"最后的、最终的"含义。变量一旦赋值后，不能被重新赋值。
final的特征：
- final 修饰的实例变量必须显式指定初始值。可以在构造函数和普通代码块中赋值，但是只能赋值一次
- final 修饰符通常和 static 修饰符一起使用来创建类常量。可以在静态代码块中赋值，但是只能赋值一次
- final 类不能被继承，没有类能够继承 final 类的任何特性。
- 父类中的 final 方法可以被子类继承，但是不能被子类重写。
**注：**声明 final 方法的主要目的是防止该方法或者类的内容被修改。
package com.star.demo12;
public class Math {
// 圆周率常量：static final
private static final double PI = 3.1415926;
// 求圆面积
public static final double area(double radius) {
//PI = 3;//报错
return PI * radius * radius;
}
// 求矩形面积
public double area(double width, double height) {
return width * height;
}
}
----------------------------------------------------------------------------
package com.star.demo12;
//final修饰类，这个类不能被继承
public final class Child extends Math{
//只能复写父类的非final 和 static的方法
@Override
public double area(double width, double height) {
System.out.println("复写了父类的方法，并且调用父类的实现");
return super.area(width, height);
}
}
//报错，最终类不能被继承
//class son extends Child{}
----------------------------------------------------------------------------
package com.star.demo12;
public class Main {
public static void main(String[] args) {
System.out.println("半径为12.5的圆面积："+Child.area(12.5));
System.out.println("长为20，宽为10的矩形面积："+new Child().area(20,10));
}
}
结果：
abstract 抽象
abstract可以修饰类和方法。
- abstract修饰的类叫做抽象类，抽象类不能用来实例化对象
- abstract修饰的方法叫做抽象方法，抽象方法没有方法体
注：
- 一个类不能同时被 abstract 和 final 修饰
- 抽象方法不能被声明成 final 和 static。
如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误
声明抽象类的唯一目的是为了将来对该类进行扩充
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
package com.star.demo13;
//带有抽象方法的类必须加abstract申明为抽象类
public abstract class AbsClass {
//抽象方法，不能写方法体｛...｝
public abstract void fun1();
//非抽象方法必须写方法体｛...｝
public void fun2() {
System.out.println("AbsClass的抽象方法：fun2");
}
}
----------------------------------------------------------------------------
package com.star.demo13;
public class Child extends AbsClass{
//继承抽象类必须实现抽象类未实现的抽象方法
@Override
public void fun1() {
System.out.println("被子类实现的方法：fun1");
}
}
----------------------------------------------------------------------------
package com.star.demo13;
public class Main {
public static void main(String[] args) {
//AbsClass absClass = new AbsClass();//抽象类不能被实例化
AbsClass absClass = new Child();//能被实例化
Child child = new Child();
absClass.fun1();
absClass.fun2();
child.fun1();
child.fun2();
}
}
Java四大存储域
| 存储域 | 特征 |
|---|---|
| 堆 | 堆内存用来存放由new创建的对象和数组。 jvm只有一个堆区(heap)被所有线程共享。 |
| 栈 | 栈中存用数组或对象在堆内存中的首地址（32位4字节，64位8字节）、函数中定义的一些基本类型的变量数据 每个线程包含一个栈区，每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问 |
| 方法区 | 方法区用于存储虚拟机加载的类信息、静态变量、即时编译器编译后的代码等数据。 方法区跟堆一样，被所有的线程共享。 |
| 常量池 | 常量池指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。 包含代码中所定义的各种基本类型（如int、long等等）和对象型（如String及数组）的常量值(final) |
Java匿名内部类
匿名类就是没有使用变量保存起来，使用一次以后就不再使用的类
包括普通匿名类和匿名内部类
内部类创建方法:外部类对象.new 内部类()
package com.star.demo07;
public class User {
private String name = "UserName";
String sex = "男";
protected int age = 20;
public String address = "地球";
//内部类
class Inner{
private String name = "InnerName";
String sex1 = "女";
protected int age = 30;
public String address = "月球";
public void show() {
System.out.println(name);
System.out.println(sex);
System.out.println(sex1);
System.out.println(age);
System.out.println(address);
}
}
public void show() {
System.out.println(name);
System.out.println(sex);
//System.out.println(sex1);
System.out.println(age);
System.out.println(address);
}
}
----------------------------------------------------------------------------
package com.star.demo07;
import com.star.demo02.User.Inner;
public class Main {
public static void main(String[] args) {
User user = new User();
user.show();
Inner inner = user.new Inner();
inner.show();
}
}
JAVA面向接口
接口是一种新类型，有别于类，但是又和类类似
接口相当于非常特殊的抽象类，只要public****抽象函数*和*常量****
接口没有构造方法，因此接口不能被实例化，只能被实现，故子类使用【*implements*】关键词来实现接口
一个子类可以实现多个接口（多实现）
接口特性：
- 接口中每一个方法也是隐式抽象的，会被隐式的指定为 public abstract（也只能是 public abstract，其他修饰符都会报错）。
- 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
- 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
default关键字用于实现默认的方法
default void bite() {
System.out.println("默认实现的方法");
}
package com.star.demo14;
public interface Mather {
//只能是public static final，且必须赋值
public static final String firstname = "陶";
public static final String lastname = "琪";
public static final String sex = "女";
// 默认为public
void beautify();
default void bite() {
System.out.println("默认实现的方法");
}
}
----------------------------------------------------------------------------
package com.star.demo14;
public interface Father {
//只能是public static final，且必须赋值
public static final String firstname = "太";
public static final String lastname = "史慈";
public static final String sex = "男";
// 默认为public
void strong();
}
package com.star.demo14;
public class Son implements Father, Mather {
public String firstname;
public String lastname;
public String sex;
public Son() {
this.firstname = Father.firstname + Mather.firstname;
this.lastname = "气";
this.sex = Math.random() + 1 > 0 ? "男" : "女";
}
@Override
public void beautify() {
System.out.println("漂亮");
}
@Override
public void strong() {
System.out.println("强壮");
}
}
----------------------------------------------------------------------------
package com.star.demo14;
public class Main {
public static void main(String[] args) {
Mather mather = new Son();
Father father = new Son();
Son son = new Son();
mather.beautify();//只有Mather的beautify方法
father.strong();//只有Father的strong方法
son.beautify();//不仅有beautify方法
son.strong();//还有strong方法
}
}
练习：
1、 学生成绩统计，有一个班级学生10人，循环录入10学生的分数，统计并显示
提示：创建学生类（学生姓名+成绩）
1.显示学生姓名 + 成绩
2.统计班级的总分、平均分、及格率
3.显示不及格的学生姓名 + 成绩
2、 模拟一扑扑克牌，54张牌，
花色有：红桃，梅花，黑桃，方块，
牌面值有：A，1-10，J，Q，K
分析有哪些类，并创建出54张牌对象。
提示：每张牌：Card（颜色（数值，文字）），Value（值（数字，文字））
81
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
