JAVA 学习笔记

JAVA中的new关键字

想创建一个lei的具体实例？

答：那就new吧！

重载的定义？

答：如果一个类中有多个的返回值相同，方法名相同的方法，唯独只有参数类型不相同！

这个就可以构成重载，java在实例对象调用这个方法的时候，可以区分开是调用的那个方法！ //这里搞错了返回值可以不相同，但是方法名必须相同。并且参数列表不同（ps：这样调用这个方法的时候才能区别开）

比如

class Test{
    void max(int a, int b)
    {
        System.out.println("现在我在int");
        System.out.println(a>b?a:b);
    }
    void max(float a, float b)
    {
        System.out.println("我现在float");
        System.out.println(a>b?a:b);
    }
    void max(double a, double b)
    {
        System.out.println("我现在double");
        System.out.println(a>b?a:b);
    }
}

public class TestPoint{
    public static void main(String[] args)
    {
        Test t = new Test();
        t.max(1,2);
        t.max(1.0,2.0);
        t.max(1.0f,2.0f);
    }
}

构造函数

构造函数是指在我们建立一个对象的实例的时候调用的那个方法

如果我们自己没有定义一个构造函数

系统会自动给我们定义一个空的构造函数

比如

class Cat{
	
}
与下面这个类是等价的
class Cat
{
			Cat(){};
}

Cat cat = new Cat();

在建立一个新类且继承了其他类的时候，写子类的构造方法时必须调用父类的构造方法（没有你爸爸哪来的你？你说是吧！）

JAVA 中的static关键字的个人理解

一个修饰符

如果在一个类的方法前面加上这个关键字，我们不需要new一个对象就可以访问这个方法

比如：

public class TestStatic{
    public static void main(String[] args)
    {
        Cat.fStatic();        //可以访问
        //Cat.fNotStatic();    //错误，不能访问。必须new一个具体的对象以后才能访问
        
    }
}

class Cat {
    public static void fStatic()
    {
        System.out.println("this is a static test");
    }
    public void fNotStatic()
    {
        System.out.println("this is\'n no static test ");
    }
}

JAVA中约定的命名规则：
1.类名首字母大写

2.方法名，变量名首字母小写

3.采用驼峰命名法，何为驼峰命名法。就是比如helloWorld，testInt.除了首字母以外，每个单词的首字母大写

JAVA 中的this关键字

this关键字通常使用在定义一个类其中的方法，为了区分动态属性和方法参数。

this关键字指这个类实例对象以后的这个对象本身；

比如

class  Cat{
	int i;
	void f(int i)
	{
		this.i = i;		//this.i  指的是上面的动态属性，i 指的是参数列表中的i
	}
}

pakcage和import

为了区分开同名的类。

java引用了包的机制

package com.ysger.test;

class  Cat{
	int i;
	void f(int i)
	{
		this.i = i;		//this.i  指的是上面的动态属性，i 指的是参数列表中的i
	}
}

Java中的重写：

　　1.子类对象对从父类对象继承的方法不满意时，可以选择重写，需要遵循如下规则

　　　　1.重写的方法必须更父类对象拥有相同的返回值，相同的方法名，相同的参数列表

　　　　2.重写的方法不能拥有比被重写的方法更严格的访问权限。

　　2.提示

　　　　当我们重写时候，最好去父类对象直接copy这个方法的方法头，要不然会出现超出我们预期的结果，这种错误往往是很难排除的！

　　　　还有一点，坚持就是最好的成功

package语句必须写到源码的第一句

这个类对应的文件路径名应该是包名后面的语句用“.”分割开的路径

包名约定的命名方法是.公司域名倒过来.比如说www.baidu.com，他的包名就是com.baidu.www。对应的路径是:com/baidu/www.

要使用这个类的时候需要用到import语句，导入包名就可以了

import com.ysger.test;

class  Cat{
	int i;
	void f(int i)
	{
		this.i = i;		//this.i  指的是上面的动态属性，i 指的是参数列表中的i
	}
}

多态:

多态形成的必要条件

有继承
有重写
父类对象引用子类对象本身

public class  TestStatic {
	public static void main(String[] args)
	{
		Animal a = new Cat();
		a.f();
	}
}

class Animal{
	void f()
	{
		System.out.println("Animal is Call");
	}
}

class Cat extends Animal {
	void f()
	{
		System.out.println("Cat is Call");
	}
}
class Dog extends Animal {
	void f()
	{
		System.out.println("Dog is Call");
	}
}

final关键字

final 关键字可以修饰动态属性，方法，类

修饰动态属性时代表这个动态属性，不能重新赋值
修饰方法是方法时代表这个方法不能被重写
修饰类时代表这个类不能被继承

public class  TestStatic {
	public static void main(String[] args)
	{
		Animal a = new Cat();
		a.f();
	}
}

final class Animal{
	final void f()
	{
		System.out.println("Animal is Call");
	}
}

class Cat extends Animal {
	void f()
	{
		System.out.println("Cat is Call");
	}
}
class Dog extends Animal {
	void f()
	{
		System.out.println("Dog is Call");
	}
}

上面编译时会出现如下问题
TestStatic.java:16: 错误: 无法从最终Animal进行继承
class Cat extends Animal {
                  ^
TestStatic.java:22: 错误: 无法从最终Animal进行继承
class Dog extends Animal {
                  ^
TestStatic.java:17: 错误: Cat中的f()无法覆盖Animal中的f()
        void f()
             ^
  被覆盖的方法为final
TestStatic.java:23: 错误: Dog中的f()无法覆盖Animal中的f()
        void f()
             ^
  被覆盖的方法为final
4 个错误

java中super关键字

其实super这个关键字我觉得是和this 关键词是一一对应的

this指的是实例话以后的对象本身

super指的是继承父类以后子类直接访问父类属性或方法的关键词 //　　自己说起来都有点绕口

抽象类

用abstract来修饰一个类时，这个类被称为抽象类！
用abstract来修饰一个方法是，这个方法必须被重写!
含有抽象方法的类必须被声明为抽象类，抽象类必须被继承。抽象方法必须被重写
抽象类不能被实例化
抽象方法只需要声明，而不需要实现.

JAVA中的继承用extends关键字

class xxx extends yyy｛

｝            //xxx继承yyyy

java中的泛型

Java中的instance关键字

　　x instance y 来判断x是否是y类的一个对象！

　　如果是返回ture

　　否则返回false

posted @ 2015-04-24 02:18 YsGer 阅读(131) 评论(0) 收藏举报

刷新页面返回顶部

YsGer

JAVA 学习笔记

公告