Java核心技术卷1 - 基础知识

第二章 Java环境

第三章 Java 基本结构

>>>运算符会用 0 填充高位，这与>>不同，它会用符号位填充高位。不存在<<<运算符

运算符

printf

转换符

标志

第四章 对象与类

OOP

识别类的简单规则是在分析问题的过程中寻找名词，而方法对应着动词。

类与类之间的关系

在类之间， 最常见的关系有

• •依赖（“ uses-a”）
• •聚合（“ has-a”）
• •继承（“ is-a”）

包

import 语句不仅可以导人类，还增加了导人静态方法和静态域的功能。
例如，如果在源文件的顶部， 添加一条指令：

• import static java.lang.System.*;

就可以使用 System 类的静态方法和静态域，而不必加类名前缀：

out.println(“Goodbye, World!”); // i.e., System.outexit⑼; //i.e., System.exit

另外，还可以导入特定的方法或域：

• import static java.lang.System.out;

实际上，是否有更多的程序员采用 System.out 或 System.exit 的简写形式，似乎是一件值
得怀疑的事情。这种编写形式不利于代码的清晰度。不过，

• sqrt(pow(x, 2) + pow(y, 2))

看起来比

• Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2))
  清晰得多。

第五章 继承

警告：在覆盖一个方法的时候，子类方法不能低于超类方法的可见性。特别是， 如果超类 方法是 public, 子类方法一定要声明为 public。经常会发生这类错误：在声明子类方法的时 候， 遗漏了 public 修饰符。此时，编译器将会把它解释为试图提供更严格的访问权限。

第六章 接口、lambda表达式、内部类

lambda

是的，Lambda表达式可以被看作是一种简化的局部内部类，它具有与局部内部类相似的特性。

Lambda表达式和局部内部类都可以用于在方法内部定义一个函数式接口的实现。它们都可以访问方法的局部变量和参数，以及外部类的成员变量和方法。

Lambda表达式和局部内部类的相同特性包括：

1. 可以访问方法的局部变量和参数：

   • Lambda表达式和局部内部类都可以访问方法的局部变量和参数，但有一些细微的差别。

   • 匿名内部类可以访问外部类的成员变量和方法，包括可变和不可变的变量。这是因为匿名内部类在编译时会生成一个新的类，它可以访问外部类的所有成员。

     Lambda表达式与匿名内部类类似，也可以访问外部类的成员变量和方法。但是，Lambda表达式对外部变量有一定的限制。Lambda表达式可以访问外部的不可变（final或等效于final）变量，以及实际上不会改变的局部变量。这是因为Lambda表达式的实现方式与匿名内部类有所不同，它使用了不同的变量捕获机制。

2. 可以访问外部类的成员变量和方法：

   • Lambda表达式和局部内部类都可以访问外部类的成员变量和方法，包括静态和非静态成员。

3. 可以实现函数式接口：

   • Lambda表达式和局部内部类都可以实现函数式接口，即只有一个抽象方法的接口。

然而，Lambda表达式和局部内部类也有一些不同之处。Lambda表达式更加简洁，可以通过推断类型来省略参数类型的声明，而局部内部类需要显式声明参数类型。此外，Lambda表达式的语法更加紧凑，可以在一行代码中定义函数式接口的实现。

总的来说，Lambda表达式可以看作是一种简化的局部内部类，它具有与局部内部类相似的特性，但语法更加简洁和紧凑。

对于Lambda表达式，它可以访问外部类的成员变量和局部变量的规则与匿名内部类类似。

外部类的成员变量：

Lambda表达式可以直接访问外部类的成员变量，包括私有成员变量。
在Lambda表达式中，可以直接访问外部类的成员变量，如outerVariable。
局部变量：

对于Lambda表达式，它可以访问外部类的局部变量，但是这些局部变量必须是final修饰的，或者事实上是final的（即在Lambda表达式中不修改该变量的值）。

public static void repeat(String text, int count)
{
    for (int i = 1; i <= count; i++)
    {
    	ActionListener listener = event ->
        {
            System.out.pn'
            nt1n(i + ": " + text);
            // Error: Cannot refer to changing i
   	 	}；
    	new Timer(1000, listener).start();
    }
}

/*这里有一条规则：lambda 表达式中捕获的变量必须实际上是最终变量 ( effectivelyfinal。)
实际上的最终变量是指， 这个变量初始化之后就不会再为它赋新值。在这里，text 总是指示
同一个 String 对象，所以捕获这个变量是合法的。不过，i 的值会改变，因此不能捕获。*/

{
    Path first = Paths.get(7usr/Mn");
    Couparator<String> comp =
    	(first, second) -> first.length() - second.length();
   		// Error: Variable first already defined == first
}
 /*lambda 表达式的体与嵌套块有相同的作用域。这里同样适用命名冲突和遮蔽的有关规
则。在 lambda 表达式中声明与一个局部变量同名的参数或局部变量是不合法的。*/                      

public class ApplicationO
{
    public void init()
    {
    	ActionListener listener * event ->
        {
            // 当前lambda 作用域的this
        	System.out.print n(this.toStringO);
        };
    }
}

/*在一个 lambda 表达式中使用 this 关键字时， 是指创建这个 lambda 表达式的方法的 this
参数。*/

关于java外部类和内部类的基础知识 - 掘金 (juejin.cn)

内部类

普通内部类

成员、局部、匿名

Java允许一个类被定义在另一个类中，这样的类就称为嵌套类。嵌套类分为两种：静态的和非静态的。没有用 static来声明的嵌套类，就称为非静态嵌套类，非静态嵌套类又称为内部类。 主要包含三种类型 成员内部类、局部内部类和匿名内部类

• 成员内部类

在一个类中定义的类，作为外部类的一个成员，与外部类的属性，方法级别是一样的，它可以访问外部类的私有成员和属性。但是外部类想要访问内部类的成员则需要建立内部类对象去访问。

注意：内部类和外部类之间有同名成员时，内部类可以以外部类名.this.变量名 访问外部类成员；在成员内部类不能存在static 关键字（不能有静态方法，静态属性，静态代码块等）

• 局部内部类

从名字就可可指，这种类是一种局部的，和局部变量有些相似，一般局部内部类是定义在一个方法中定义的内部类，不能使用private，protected，public修饰符，也不能存在static 关键字

• 匿名内部类

匿名类能够使代码更加简洁，它们能够同时声明和实例化一个类。它们就像本地类，只是它们没有名称（本地类是类声明，而匿名类是表达式）

public class Test {
   interface Hello{
       public void greet();
       public void greetToPeople(String name);
   }
   public void sayHello(){
       //局部内部类
       class EnglishGreeting implements Hello{
           String name = "wzy1";
           @Override
           public void greet() {greetToPeople(name); }
           @Override
           public void greetToPeople(String name) {System.out.println("Hello "+name); }
       }
   Hello hello1 = new EnglishGreeting();
       //匿名内部类
    Hello hello2 = new Hello() {
       String name = "wzy2";
        @Override
        public void greet() {greetToPeople(name);}
        @Override
        public void greetToPeople(String name) { System.out.println("Hello "+name);}
    };
    hello1.greet();
    hello2.greet();
   }

    public static void main(String[] args) {
        Test test = new Test();
        test.sayHello();
    }
}

运行结果：

上面代码中使用了两种类型的内部类：一种是局部内部类EnglishGreeting，一种是匿名内部类hello2，局部内部类有自己的类名，使用时需要实例化，而匿名内部类是一个表达式，直接就可以new一个表达式。匿名内部类和局部内部类都可以访问外部类的所以成员

匿名内部类是没有类名字的内部类，是一个表达式，因此只能使用一次，但是要使用匿名内部类必须要继承或实现一个接口才能使用。

静态内部类

上面三种类型的内部类和静态内部类之间有什么区别呢？内部类是以外部类为前提的，没有外部类就无法谈内部类；静态内部类可以自己完全独立存在，但是他可以以外部类作为依托。

使用static修饰的内部类就是一个静态内部类。

public class Test {
    private String name1 = "wzy1";
    private static String name2 = "wzy2";
   public void testage(){
       System.out.println(new InnerClass().age1);
       System.out.println(InnerClass.age2);
   }
   static class InnerClass{
       private int age1= 18;
       private static int age2 = 20;
       public void hello(){
           System.out.println("Hello "+name2);
       }
   }
    public static void main(String[] args) {
       Test test  = new Test();
       test.testage();

       InnerClass in = new InnerClass();
       in.hello();
    }
}

静态内部类InnerClass 只能访问外部类的类成员 不能访问实例成员（如访问name1就问报错） 外部类可以使用静态内部类：类名.来访问类成员或者也可以使用对象的方式来访问。

第七章 异常、断言