java学习笔记（面向对象之前）

1

CLASSPATH

%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;

2

最近在看Java，在编译写书上一个例子时，由于书上的代码只有一部分，于是就自己补了一个内部类。结果编译时出现：No enclosing instance of type E is accessible. Must qualify the allocation with an enclosing instance of type E(e.g.  x.new A() where x is an instance of E). E指代我写的那个内部类。

根据提示，没有可访问的内部类E的实例，必须分配一个合适的内部类E的实例（如x.new A()，x必须是E的实例。）看着这句提示，我就纳闷了，我已经用new实例化了这个类，为什么还不行呢。

于是百度谷歌了一下相关资料。原来我写的内部类是动态的，也就是开头以public class开头。而主程序是public static class main。在Java中，类中的静态方法不能直接调用动态方法。只有将某个内部类修饰为静态类，然后才能够在静态类中调用该类的成员变量与成员方法。所以在不做其他变动的情况下，最简单的解决办法是将public class改为public static class.

在这里记下这个问题，也方面遇到同样问题的朋友查阅。

3 java命令不用设置环境变量也可以使用

因为使用java的windows安装包，java.exe会被拷贝到system32目录下去，通常情况下system32都是PATH环境变量的一部分，所以直接敲java可以找到。
但是javac.exe是不会拷贝过去的，所以找不着

C:\Windows\System32

4

pointp1=newpoint(0, 0, 0);

System.out.println( p.distance(newpoint(0, 0, 0)));

在stack 栈内存局部变量和 heap 堆内存分配（ new 出来的东西）是一样的，都会在栈里面分配内存，然后消失·~

 

 

 

Pink 笔记

J2se Jdk

局部变量 ：方法或语句块内部定义的变量

成员变量 ：方法外部，类内部定义的变量

注意：类外面（与累对应的大括号外面）不能有变量的声明

 

 

4个内存区域

 

Code segment 存放代码

Data segmen 静态变量， 字符串常量

Stack 局部变量 ，栈内存

Heap 堆内存 new 出来的东西

 

 

 

反码 补码 原码

1. 原码

 

原码 ： 第一位 0 代码正号 1代表 负号

[+1]_原 = 0000 0001

[-1]_原 = 1000 0001

 

[1111 1111 , 0111 1111]

即

[-127 , 127]

2. 反码

反码的表示方法是:

正数的反码是其本身

负数的反码是在其原码的基础上, 符号位不变，其余各个位取反.

[+1] = [00000001]_原 = [00000001]_反

[-1] = [10000001]_原 = [11111110]_反

 

3. 补码

补码的表示方法是:

正数的补码就是其本身

负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)

[+1] = [00000001]_原 = [00000001]_反 = [00000001]_补

[-1] = [10000001]_原 = [11111110]_反 = [11111111]_补

_{计算机中是按照补码计算的}

_{char byte short} 这三种计算时默认转化为int

int long

float double 计算时默认转化为double

除此外遵循规则转化为大的

Long l1=123L 本身就是long类型

Long l1=123 是int 转化为long 小转大不用强制转换

 

Break 直接退出循环，不进行下一次

Continue 终止此次循环，进行下一次

Return 直接结束方法

 

Fibonacci 数列

 

观察规律

 

F1=1 ， F2=1

Fn=Fn-1+fn-2

可得代码

If(n==1||n==2){

Retur 1;

}else{

Return fn-1+fn-2;

}

计算时 是先计算完整的 分析内存

 

也可以不用递归

For循环

 

 

第三章 面向对象

类是用来描述一类的对象的一个抽象概念

有成员变量和成员方法

类可看做一类对象的模板，对象可以看成类的具体实例

 

Xx是xx就是继承

整体和部分 就是聚合关系

接口 实现关系

多态

 

思维

1. 哪些类，哪些对象
2. 类，对象的属性
3. 类之间的关系，方法

成员变量可以有默认值

 

方法的定义

修饰符 返回类型 方法名 （参数） { 方法体 }

构建新对象时使用的方法叫做构造方法 一般有public 修饰词 与类同名无返回值

 

默认的具有无参数的构造方法

1. 方法调用完成后，栈内存分配的空间全部消失
2. 当自己定义构造方法后，默认的无参数的构造方法消失， 需自己重新定义

 

 

 

约定俗称的命名规则

1. 类名的首字母大写
2. 变量名和方法名的首字母小写
3. 运用驼峰标示

 

 

调用方法是编译器能区分开来就是重载， 构造方法也能重载

 

几个关键字

This 关键字

 

使用this 关键字代表使用该方法的对象的引用

 

Static 关键字

Static代码块，在类加载时运行，先运行，而且只运行一次，如果多个 按顺序

如 static int a=1;

Static { System.out.println("2")} 也会被继承 顺序如1 2

Static修饰的成员变量为静态成员变量，是该类公用变量，第一次使用时初始化

在内存中只有一次，跟随类加载时运行，先运行，比构造方法还先。因为类也只加载一次

 

Static

1. 修饰的方法为静态方法，不能讲对象传递给它 ，
2. 静态方法不能访问非静态的变量 ，
3. main方法就为静态方法， 所以不能不实例化就执行
4. 静态方法不能被重写
5. 但是非静态的方法就访问静态的东西
6. 子类可以继承父类的静态方法！但是不能覆盖。因为静态方法是在编译时确定了，不能多态，也就是不能运行时绑定

    

权限修饰符

修饰符	类内部	同一个包	子类	任何地方
Private	√
Default	√	√
Protected	√	√	√
Public	√	√	√	√

 

 

继承

子类自动拥有父类 extends

1. Java 只支持单继承

    

   Super 关键字

2. 父类的， super一定写在子类构造方法的第一行，
3. 子类构造方法必须调用父类的构造方法（默认调用的是无参数的构造方法）

 

Object 类

 

所有类均具有继承object override重写了 toString方法

Equals 比较 是根据引用的是否为相同的指向，有的类将equals 重写了， 如

String 类

 

Instanceof 对象类型相比

 

对象转型

Casting 有父类转型子类 不能访问子类属性和方法

必须强制转换

如 animal a =new dog （" "," "）

 

重写:子类引用父类 ，修饰符子类至少大， 返回类型和参数一样

重载：位于一个类中，参数类型或参数数量不一样

 

 

多态， 也叫动态绑定

 

就是动物叫声那个例子 实际为new 的对象

 

增加了可扩展性，面向对象的核心

条件

 

1. 继承
2. 重写
3. 父类引用指向子类对象

 

关键字 abstract 可以设置抽象方法

动物叫声 父类方法必须有叫声，需要继承后重写

Abstract方法必须没有方法体

含有抽象方法的类必须声明为抽象类，

1. 抽象方法存在的意义就是被重写，等待子类具体实现它
2. 抽象的类不能实例化了，抽象类存在的意义就是被继承

 

Final 关键字

1. final类不能被继承
2. final方法不能被重写 static也一样
3. 变量（成员变量，局部变量） 需要被初始化，一旦初始化就不能被更改。

   如果成员变量不被初始化，可以在构造方法中初始化，但必须保证实例创建后final成员变量一定会被初始化 或者static代码块中（此时必须声明为静态）

4. final修饰的如果是引用类型， 保证的是在栈内存指向堆内存的指针不会变，但位于堆内存的值可以变

    

interface 接口

接口中的方法不能用 abstract 修饰，默认为public， 常量默认为public static final

 

如果一个子类继承自父类， 必须重写抽象方法，否则表明子类是抽象的

接口也一样，接口的方法也是必须全部被重写，否则标为抽象

接口之间也可以继承，则如果实现接口，则必须重写 子类父类的所有方法

 

两个例子

 

/*

* Myclass 第一个属性加了static

* In ClassA Static

ClassA()

In MyClass Static

In ClassB Static

In ClassC Static

ClassB()

ClassC()

MyClass()

ClassB()

ClassC()

MyClass()

false

true

 

 

*

*

* Myclass 第一个属性不加static

* In MyClass Static

In ClassA Static

ClassA()

In ClassB Static

In ClassC Static

ClassB()

ClassC()

MyClass()

ClassA()

ClassB()

ClassC()

MyClass()

false

false

 

*

*/

 

class ClassA {

    static {

        System.out.println("In ClassA Static");

    }

 

    public ClassA() {

        System.out.println("ClassA()");

    }

}

 

class ClassB {

    static {

        System.out.println("In ClassB Static");

    }

 

    public ClassB() {

        System.out.println("ClassB()");

    }

}

 

class ClassC extends ClassB {

    static {

        System.out.println("In ClassC Static");

    }

 

    public ClassC() {

        System.out.println("ClassC()");

    }

}

 

class MyClass {

     static ClassA ca = new ClassA();

    ClassC cc = new ClassC();

    static {

        System.out.println("In MyClass Static");

    }

 

    public MyClass() {

        System.out.println("MyClass()");

    }

}

 

publicclass静态 {

    publicstaticvoid main(String args[]) {

        MyClass mc1 = new MyClass();

        MyClass mc2 = new MyClass();

        System.out.println(mc1.cc == mc2.cc);

        System.out.println(mc1.ca == mc2.ca);

    }

}

 

 

Two

 

publicclass Text6{

     

     public Text6(int a) {

         System.out.println("Text6");

    }

      

     static{

         System.out.println(" static + Text6");

     }

 

    publicstaticvoid main(String[] args) {

 

     Text7 t7=new Text7(10);

 

    }

 

}

 

class Text7 extends Text6{

      

     publicText7(int a) {

         super(10);

         System.out.println("Text7()int");

    }

     

}/*static + Text6

Text6

Text7()int

*/

 

 

 

7月5日考试 第五章和第六章