Java学习笔记一和前言

  

  发表在这里的笔记，是我从学习Java开始所记下的笔记，我已经翻阅了无数次，应该说是非常的详细，我希望对后来的Java学习者能够有所帮助，我也希望，大家能够养成记笔记的习惯，这样可以在需要的时候拿来翻阅，而不至于忘掉知识点之后就无从下手了。

 

开始面向对象的学习

（thinking in java每天看三页）

1.所谓浮点型就是小数，也叫做实数。

2.强制转换类型：类型 变量名=（类型）变量名，或者在变量名后面加上f

3.原声数据类型有八种

4.问题：如何进行粘贴转换？

5.int a = 1, int b=2; double c =a/b,如果这样写结果可以赋值给c但是结果是0.0，所以应该强制类型转换（double）a.

6.  取模运算符：%。

7.取模的结果符号永远与被除数相同。

8.a=a+1,等价于a+=1.

9.b=a++,即先把a的值付给b,a再自增1，b=++a,先将a的值自增1后在将a的值付给b,使我们主观上常用的做法。

10.java新增了一种条件运算符 （三元运算符），type a=条件 ？结果一；结果二； 即 如果条件是真 则a的值为结果一，为假为结果二。

例如。int a=1<2?3;4; 

11.break  在for循环中直接跳出循环、

oop 面向对象

12.面向对象包括三大特征 继承、封装、多态

13.class 表示我要定义一个类， class后面接类的名字

14.main是一种方法，是整个java程序的入口点

15.方法定义不能嵌套。

16.通过类来生成对象

17.public classperson//定义一个 名字为 person的类

{

                    

 

}

调用方法时要生成类的对象，因为主方法可以调用多个类。

18. 区别成员变量与局部变量，局部变量是定义在方法中的变量，成员变量是定义在类中的变量，相当于主函数

19.局部变量使用前必须初始化，而成员变量可以不用初始化

20.执行的是包含main方法的类

21.类又叫做实例，可以说类生成了对象（object），也可以说类生成了实例。（instance）

22.定义在类中的变量叫做成员变量，定义在方法中的变量叫做局部变量

22.数据在类中称为属性或者成员变量，对数据的操纵在类中成为方法。

23.有一个人（类），叫张三（对象），张三的退（数据或属性）在奔跑（方法）

24.封装（encapsulation）：类包含了数据与方法，将数据与方法放在一个类中就构成了封装

25八种原生类型外的变量类型，系统默认初值为null;String a,输出结果为Null

 

 

1.

今天开始学习继承

2. 牢记super的用法

当在子类的构造函数需要调用父类的构造函数时，使用super（），这样做，就可以不用遵循系统只能默认调用父类没有参数的方法，而是使用父类中有参数的方法。当然super（）,里面可以加形参（根据具体的父类的构造函数是否需要形参），这条语句必须写在子类构造函数的第一句；

3.继承，子类可以继承父类中的属性，和方法，即使自身没有属性；

4.关于继承的三点

a).父类有的，子类也有；

b).父类没有的，子类可以增加；

c).父类有的，子类可以改变，这叫做方法重写；

3.super只能使用在构造函数中！！！而且必须是构造函数的第一个语句；！

但是，super. 是可以使用的，而且没有顺序限制，使用在子类的语句中，表示调用父类的某个方法，如super.run,表示在子类中调用父类中run方法，二者是先执行的。这样做就可以让子类与父类的语句都执行；

4.

Flower rose = new Rose ();，指向谁就会调用谁的方法--意思是生成一个Flower类型的引用指向Rose的对象，父类可以指向子类，而子类不能指向父类，玫瑰是花，但花不是玫瑰！

5.

方法重载是让类以统一的方式处理不同类型数据的一种手段。Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法,。

方法重载不是多态的一种表现，方法重写才是！因为它不是面向对象的

6.

我们把实参，称为 变元，把形参称为参数，就是方法中定义的

7.

方法返回给调用者的两种形式

  方法通过使用return语句返回，如果方法有一个void类型的返回类型，则在到达花括号之前，可以通过return ； 来提前结束方法；

8.

冒泡排序法原则

for (i = 0; i < 9; i++)

for (j = 0;j< 9 - i;j++)

{

if (array[j] > array[j+1])

{

t = array[j];

array [j] = array [j +1];

array[j+1] = t ;

9.

Abstract class 抽象类

抽象类的特点：抽象类不能实例化（不能生成对象）；

10．

Abstract method 抽象方法; 有声明，无实现（花括号中的语句）；

抽象方法定义在抽象类中；以分号结束

11.

但是抽象类中可以包含具体的方法；

12.

抽象方法和抽象类有什么作用呢，不能实现，不能生成对象？

声明为 abstract 成员可以不包括实现代码，但只要类中还有未实现的抽象成员（抽象方法），那么这个类就是一个抽象类，抽象类的对象就不能被实例化，通常用于强制继承类必须实现某一成员.抽象类是必须要派生子类的。并且，如果子类没有实现抽象基类的所有方法，则子类也成为一个抽象类。

在继承中的作用；

通常将父类定义为抽象类，并用抽象方法，其目的是为了声明子类的目的，并将子类系统化，虽然可能不用父子类也可以实现，但是就是为了将程序系统化，目的话，增加程序的可读性；而父类的作用就是声明；

13.

接口里的方法都是抽象方法，所以就可以省略掉abstract关键字；

14.

类可以实现接口，实现使用implements关键字表示；

代表某个类实现了某个接口

15.

一个类实现了某个接口，那么该类必须要实现接口中声明的所有方法，（同名方法），如果该类是个抽象类，那么就无需实现接口中的方法了；

16.java是单继承的，也就是说某个类只能有唯一的父类，但是一个类却可以实现多个接口，接口之间使用逗号隔开

17.

多态中的类型转换有两种，一种是向上类型转换，一种是向下类型转换，

向上类型转换不需要强制转换类型，而向下是需要强制转换类型的，何谓向上与向下，向上 ：即 由子类型转换为父类型，向下：有父类型转换为子类型；

这在多态中是常常用到的；

例如 定义父类 Parent  子类  Child， 在main方法中

向上类型转换：

Child c = new Child （）；

Parent p = c  (这句是把子类的对象传递给父类，当然子类要转换为父类型的，但是多态中子类转换为父类时不需要说明的，不许要用到强制)

向下类型转换：

Parent p = new Child ();

Child c = (Child) p;很容易理解。将p转换为子类型之后，才能够指向子类实例；但是需要进行强制类型转换；

18.

public class Test

{

                        public static void main (String[] args)

                        {

                                                 /*Child child = new Child ();

                                                 Parent parent = child ;

                                                 parent.method ();

                                                 这就是向上类型引用；                                                  */

                                                 Parent parent = new Child() ;

                                                 Child child = (Child ) parent;

                                                 child.method ();//两者的结果是相同的，这是向下类型转换

                                                 }

}

class Parent 

{

                        public void method()

                        {

                                                 System.out.println("Parent is running");

                        }

}

class Child extends Parent

{

                        public void method ()

                        {

                                     System.out.println ("Child is running ");

                        }

}

18.

JAVA中的static

作用

　　有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。

　　声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共同拥有一个static变量。声明为static的方法有以下几条限制：

　　·

　　它们仅能调用其他的static方法。

　　·

　　它们只能访问static数据。

　　·

它们不能以任何方式引用this 或super（关键字super 与继承有关）。

19.

Static关键字；

以前做过，共同的实例指向同一个引用，就是我所说的引用的传递，只要其中一个引用改变了对象的属性，就会造成全部引用的对象改变；

Static类似；但是如果这样

Object object = new Object ();

Object object1 = new Object ();

实例object与object1是两个独立的实例，而且分别指向同一个对象，对象间是独立的！，那么我通过改变object改变类中的属性，是绝不会对object1的对象属性造成改变的，但是二者的对象是相同的，使用static关键字就可以修饰对象类中的属性，使之成为二者共有的，这样就会成为共用类中的属性了；

在C++中(以及其他一些语言，如 C#，Java 等面向对象的语言中)类的成员变量被声明为static（称为静态成员变量），意味着它为该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，其修改值为该类的其它所有实例所见。

20.

由static修饰的属性或方法，可以直接通过类.来调用。这是static的特性

//看我直接引用

public class Test

{

                        public static void main (String[] args)

                        {

                                                 int m = Test2.i ;

                                                 System.out.println (m);

                                                 Test2.method ();

                        }

}

class Test2

{

                        static int i = 23;

                        public static void method ()

                        {

                                                 System.out.println ("Test is true!");

                        }

}