java 学习笔记1

一时失言乱红尘 2022-08-07 08:54 138阅读 0赞

1、java多线程资料：

[http://ifeve.com/java-concurrency-thread-directory/][http_ifeve.com_java-concurrency-thread-directory]

2、enum 类，单例模式

必须提供一个私有得构造函数，并且提供一个无任何修饰符的构造函数：  adapterGateeay();private Gateway() \{\}

3、继承类初始化顺序（构造器也是static方法，尽管static关键字没有显示地写出来。因此更确切地讲，类是在其任何static成员被访问时加载的）

1）调用类的static的方法是，首先加载static 的成员，从父类到子类一次类推

2）创建类的对象时，首先加载父类：先是普通成员变量，然后是构造方法；接着是子类：先是普通成员变量，然后是构造方法

例子如下：

package chapter07;

import staticutil.Print.\*;

class Insect \{

privateint i=9;

privateint m = printInit("Insect.m initialized");

protectedint j;

Insect()\{

print("i="+ i + ", j=" + j);

j=39;

privatestatic int x1 = printInit("static Insect.x1 initialized");

staticint printInit(String s)\{

print(s);

return47;

public class Bettleextends Insect \{

privateint k = printInit("Bettle.k initialized");

publicBettle()\{

print("k="+ k);

print("j="+ j);

privatestatic int x2 = printInit("static Bettle.x2 initialized");

publicstatic void main(String\[\] args)\{

print("Bettleconstructor");

Bettleb = new Bettle();

static Insect.x1initialized

static Bettle.x2initialized

Bettle constructor

Insect.m initialized

i=9, j=0

Bettle.k initialized

k=47

j=39

4、访问修饰符范围public>protected>默认(fridenly)>private

1）public 所有的类都能访问

2）protected 同一个包内可以访问，继承的子类可以访问

3）默认不加修饰符，只是包内访问权限

4）private 只在本类中可以访问

5、static关键字的作用

1）修饰变量：只类加载时被初始化，属于类级别的范围，所有对象共享此变量，切值加载一次

2：修饰方法：不需要创建对象即可访问的方法

6、final关键字的作用

1）修饰变量：说明该对象的变量在初始化后不能再改变，不同对象可以有不同的值；如果是引用类型只引用的地址不可变

2）修饰方法：说明该方法不能被继承，private修饰的方法默认是final的

3）修饰类：说明该类不能被继承，由于不能被继承隐式指定final的所有方法为final的

7、动态绑定

1）java中除static方法和final方法（private方法属于final方法）之外，其他所有方法都是动态绑定

2）变量是在编译时确定的

classSuper \{

public int field = 0;

public int getField() \{ return field; \}

classSub extends Super \{

public int field = 1;

public int getField() \{ return field; \}

public int getSuperField() \{ returnsuper.field; \}

publicclass FieldAccess \{

public static void main(String\[\] args) \{

Super sup = new Sub(); // Upcast

System.out.println("sup.field = "+ sup.field +

", sup.getField() = " +sup.getField());

Sub sub = new Sub();

System.out.println("sub.field = "+

sub.field + ", sub.getField() =" +

sub.getField() +

", sub.getSuperField() = " +

sub.getSuperField());

\}/\* Output:

sup.field= 0, sup.getField() = 1

sub.field= 1, sub.getField() = 1, sub.getSuperField() = 0

\*///:~

//:polymorphism/StaticPolymorphism.java

//Static methods are not polymorphic.

classStaticSuper \{

public static String staticGet() \{

return "Base staticGet()";

public String dynamicGet() \{

return "Base dynamicGet()";

classStaticSub extends StaticSuper \{

public static String staticGet() \{

return "Derived staticGet()";

public String dynamicGet() \{

return "Derived dynamicGet()";

publicclass StaticPolymorphism \{

public static void main(String\[\] args) \{

StaticSuper sup = new StaticSub(); //Upcast

System.out.println(sup.staticGet());

System.out.println(sup.dynamicGet());

\}/\* Output:

BasestaticGet()

DeriveddynamicGet()

\*///:~

8、抽象类

1）关键字abstract，在抽象类中可以包含一个或多个抽象方法，也可以不包含抽想方法

2）抽象类不可以创建具体对象，只能创建子类对象

9、接口（interface）

1）所有变量都隐含是static和final的

2）所有方法都隐含是public abstract的，即使不写

10、内部类

1）内部类可以访问外部类的所有成员方法

2）创建内部类之前必须创建外部类对象，通过外部类对象创建内部类：.new

publicclass DotNew \{

public class Inner \{\}

public static void main(String\[\] args) \{

DotNew dn = new DotNew();

DotNew.Inner dni = dn.new Inner();

\}///:~

3）内部类返回外部类对象用.this

publicclass DotThis \{

void f() \{System.out.println("DotThis.f()"); \}

public class Inner \{

public DotThis outer() \{

return DotThis.this;

// A plain "this" would beInner's "this"

public Inner inner() \{ return new Inner(); \}

public static void main(String\[\] args) \{

DotThis dt = new DotThis();

DotThis.Inner dti = dt.inner();

dti.outer().f();

\}/\* Output:

DotThis.f()

\*///:~

4）匿名内部类，调用用参数的构造器，public class Parcel8 \{

public Wrapping wrapping(int x) \{

// Base constructor call:

return new Wrapping(x) \{ // Passconstructor argument.

public int value() \{

return super.value() \* 47;

\}; // Semicolon required

public static void main(String\[\] args) \{

Parcel8 p = new Parcel8();

Wrapping w = p.wrapping(10);

\}///:~

publicclass Wrapping \{

private int i;

public Wrapping(int x) \{ i = x; \}

public int value() \{ return i; \}

\}///:~

使用外部定义的对象例子，需要final修饰参数

publicinterface Destination \{

String readLabel();

\}///:~

publicclass Parcel9 \{

// Argument must be final to use inside

// anonymous inner class:

public Destination destination(final String dest) \{

return new Destination() \{

private String label = dest;

public String readLabel() \{ return label;\}

\};

public static void main(String\[\] args) \{

Parcel9 p = new Parcel9();

Destination d =p.destination("Tasmania");

\}///:~

5）嵌套类，不需要内部类对象与外围类对象之间有联系，可以将内部类声明为static

11、java泛型

[http_ifeve.com_java-concurrency-thread-directory]: http://ifeve.com/java-concurrency-thread-directory/

java 学习笔记1

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Java学习笔记（1）

相关 Java面向对象学习笔记-1

相关 Java学习——集合——HashSet[学习笔记1.0]

相关学习笔记1

相关 Java多线程学习笔记 - 1

相关【Java开发学习笔记】JavaWeb 1-10

相关 java 学习笔记1

相关 java学习笔记(annotation 注解_1)

相关 Shell学习笔记1-1

相关 JAVA NIO学习笔记1 - 架构简介