java17：修饰词

修饰词：

限定属性/方法/类的访问范围

private 只在类内部可见
publice 任何地方都可见
protected 保护

protected 受保护的
private私有的
private 只能在本类中调用;
protected表示该属性或方法可被同一包内或子类使用.
什么都不添加的 默认的

package 包 也是范围
跨包 访问

修饰符	本类	同包类	子类	其他类
默认	可以	可以	不可以	不可以
publice	可以	可以	可以	可以
protected	可以	可以	可以	不可以
private	可以	不可以	不可以	不可以

不知道范围： 就先 私有
很少使用默认作为修饰词

尽可能私有 ==》 尽可能的封装

类的修饰可以使用publice 和默认

publice 修饰的类可以被任何类使用
默认访问控制的类只可以被同一个包中的类使用
protected 修饰内部
private 修饰内部

私有方法不能被继承，不能被重写 被继承的方法才能重写

package day17;

public class Demo03 {

public static void main(String[] args) {
animal dog = new dog();
dog.test();// 根据对象的类型 子类的dog
// 调用 dog中的print
// 又因为dog 的println是私用方法
// java 自动的调用最近的方法
// 就又调用了 animal中的 println

}
}

class animal {
public void test() {
this.print(); // dog 的类型是 animal 他的对象是dog类型
this.println();// dog 的类型传递给了this 同样的指向了对象dog类型
}

public void print() {
System.out.println("a");
}

private void println() {// 私用方法不能重写
System.out.println("b");
}
}

class dog extends animal {
public void print() {
System.out.println("A");
}

public void println() {
System.out.println("B");
}

}

static 修饰成员变量
静态变量

静态变量是属于类的变量， 使用类名访问 静态变量只有一份

package day05;
public class D {
public static void main(String[] args) {
Dog  wangcai = new Dog("wangcai");
Dog xiaowangcai = new Dog("xiaowangcai");
System.out.println(Dog.numOfdogs);
}
}
class Dog{
String name;//实例变量
static int numOfdogs;//静态变量
public Dog(String name){
this.name = name;
Dog.numOfdogs++;
}
}

静态方法

静态方法没有隐含参数 this 没有当前对象 他属于类的方法，他用类名调用

静态方法经常用于与当前对象无关的采用静态方法

非静态方法有隐含参数 this 在那个对象上调用 this 就是那个对象

static块为属于类的代码块，在类加载期间执行的代码块，只执行一次，可以用来在软件中加载静态资源（图像、音频等等）

package day05;
public class Demo04 {
public static void main(String[] args) {
Ooo o1 = new Ooo();
Ooo o2 = new Ooo();
}
}

class Ooo{
//System.out.println("Hi");不能直接写
{System.out.println("HI");}//代码块，很少很少使用，在对象创建期间执行，类似于构造器重的代码
static {System.out.println("hi");} //static 代码块 ，在类加载期间执行用于添加静态资源
}

package day05;

public class Demo03 {

public static void main(String[] args) {
Point p1 = new Point(3, 6);
Point p2 = new Point(6, 9);
System.out.println(p1.distance(p2));
System.out.println(Point.distance(p1, p2));
}

}

class Point {

int x;
int y;

public Point(int x, int y) {
this.x = x;
this.y = y;
}

public double distance(Point other) {
int a = this.x - other.x;
int b = this.y - other.y;
return Math.sqrt(a * a + b * b);
}

public static double distance(Point p1, Point p2) {
int a = p1.x - p2.x;
int b = p1.y - p2.y;
return Math.sqrt(a * a + b * b);
}

}

内部类：
就是在类的内部定义的类
内部类用于 封装 类的实现，避免暴露细节，限制类的访问范围。

package xyz.rhel.els;

import java.util.Random;

/**
* Tetromino 这个类是抽象的 所以不能new
* so 里面的randomOne 这个方法就要用static  static 可以是使用 类名来调用方法  简单工厂方法
* randomOne 使用了static 所以下面的7个子类也要使用static
* Tetromino 的构造器是私有的所以就没有子类可以来继承
*/
public abstract class Tetromino {
private Tetromino(){}
protected Cell[] cells = new Cell[4];
public static Tetromino randomOne(){
Random r = new Random();
int type = r.nextInt(7);
switch(type){
case 0:
return new T();
case 1:
return new I();
case 2:
return new S();
case 3:
return new Z();
case 4:
return new J();
case 5:
return new L();
case 6:
return new O();
}
return null;
}

private static class T extends Tetromino{
public T(){
cells[0] = new Cell(0, 4, Tetris.T);
cells[1] = new Cell(0, 3, Tetris.T);
cells[2] = new Cell(0, 5, Tetris.T);
cells[3] = new Cell(1, 4, Tetris.T);

}
}
private static class I extends Tetromino{
public I(){
cells[0] = new Cell(0, 4, Tetris.I);
cells[1] = new Cell(0, 3, Tetris.I);
cells[2] = new Cell(0, 5, Tetris.I);
cells[3] = new Cell(0, 6, Tetris.I);
}
}
private static class S extends Tetromino{
public S(){
cells[0] = new Cell(0, 4, Tetris.S);
cells[1] = new Cell(0, 5, Tetris.S);
cells[2] = new Cell(1, 3, Tetris.S);
cells[3] = new Cell(1, 4, Tetris.S);
}
}
private static class Z extends Tetromino{
public Z(){
cells[0] = new Cell(0, 4, Tetris.Z);
cells[1] = new Cell(0, 3, Tetris.Z);
cells[2] = new Cell(1, 4, Tetris.Z);
cells[3] = new Cell(1, 5, Tetris.Z);
}
}
private static class L extends Tetromino{
public L(){
cells[0] = new Cell(0, 4, Tetris.L);
cells[1] = new Cell(0, 3, Tetris.L);
cells[2] = new Cell(0, 5, Tetris.L);
cells[3] = new Cell(1, 3, Tetris.L);
}
}
private static class J extends Tetromino{
public J(){
cells[0] = new Cell(0, 4, Tetris.J);
cells[1] = new Cell(0, 3, Tetris.J);
cells[2] = new Cell(0, 5, Tetris.J);
cells[3] = new Cell(1, 5, Tetris.J);
}
}
private static class O extends Tetromino{
public O(){
cells[0] = new Cell(0, 4, Tetris.O);
cells[1] = new Cell(0, 5, Tetris.O);
cells[2] = new Cell(1, 4, Tetris.O);
cells[3] = new Cell(1, 5, Tetris.O);
}
}
}

类的访问范围
公有类：任何位置可见
同胞类：当前包内可见
内部类：一般用于类内部可见 如果修饰词使用public 在类的外面也是可见的
局部内部类：匿名类 只在方法内部可见

匿名类的语法很简洁，经常使用。

package diyitian;
public class HelloJava {
public static void main(String[] args) {
Ooo o1 = new Ooo();
Ooo o2 = new Ooo();
Ioo too = new Ioo(){};//这个是创建的一个匿名子类 他创建的是一个子类 抽象类不能直接创建

}
}

class Ooo{
//System.out.println("Hi");不能直接写
{System.out.println("HI");}//代码块，很少很少使用，在对象创建期间执行，类似于构造器重的代码
static {System.out.println("hi");} //static 代码块 ，在类加载期间执行用于添加静态资源
}

abstract class Ioo{//抽象类

}

本文出自 “浪漫的偷笑” 博客，请务必保留此出处http://lmdtx.blog.51cto.com/6942028/1700103