Java 学习笔记（2015.7.13~17）
Java
this关键字
表示本类中的属性，调用本类中的方法
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;//调用本类中的属性
this.age = age;//同上} //get&set方法：
public String getName() {
return name; }
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void tell() {
System.out.println("姓名："+this.getName()+"年龄："+this.getAge());
}
}调用构造方法
调用时必须写在构造方法的第一行。
public Person(String name, int age) {
this();
//调用无参数构造方法
this.name = name;
this.age = age;
}
public Person() {
System.out.println(""无参数构造方法);
}表示当前对象
举个栗子：
class Person {
public void tell() {
System.out.println(this);
}
}
public static void main(String args[]) {
Person p1 = new Person();
System.out.println(p1);
p1.tell();
}输出的结果是一样样的，这里this引用了当前对象也就是自己。
离线版Android SDK ，IDEA
栈内存中保存的是堆内存空间的访问地址。
封装性，用private保护起来，不让外部直接访问，一般使用setter&getter方法获得属性。
String 两种实例化方法的区别。
直接赋值，生成一个匿名对象。
标准的new构造方法
使用直接赋值即匿名对象的优势：如果一个字符串已经被一个对象引用，则以后再有相同的字符串声明时，就不会再重新开辟空间。
比较下面两个程序
1
public class Test1 {
public static void main(String args[]) {
String str1 = "hello";
System.out.println("fun()方法调用之前：" + str1);
fun(str1);
System.out.println("fun()方法调用之后：" + str1);
}
public static void fun(String str2) {
str2 = "MLDN";
}
}输出:
fun()方法调用之前：hello
fun()方法调用之后：hello
字符串的内容不可改变，修改字符串时实际上是new出了一个新字符串并改变了内存地址。形参指向了"MLDN"的内存地址。
2
class Demo {
String temp = "hello";
}
public class Test2 {
public static void main(String args[]) {
Demo d1 = new Demo();
d1.temp = "world";
System.out.println("fun()方法调用之前：" + d1.temp);
fun(d1);
System.our.prtinln("fun()方法调用之后：" + d1.temp);
}
public static void fun(Demo d2) {
d2.temp = "MLDN";
}
}输出:
fun()方法调用之前：world
fun()方法调用之后：MLDN
本例修改的是对象的属性！是堆内存对象内部的修改！ 哈哈哈，终于懂了
this关键字
表示类中的属性
调用本类中的构造方法（必须写在构造方法的第一行；构造方法间相互调用时 ）
表示当前对象
对象的比较
== 比较内存地址，equals比较内容。要想比较对象，必须比较其内容，若类中没有重写equals方法，则要比较其属性内容。
static关键字
static声明的属性叫做全局属性或类属性（类里声明的变量为成员变量，方法里声明的变量为局部变量）
static声明的属性是所有对象共享的，所以用类名称.static属性的方式调用更好
static声明的方法叫做类方法，用类名引用
用static 声明的方法，不会将对象的引用传递给它。讲人话谢谢。
答：static声明的方法不能调用非static的属性和方法（门当户对）。因为程序中的所有属性和方法必须在对象开辟开辟对内存后才能调用，而static类的方法在对象未被实例化时就可以用类名调用。
因为static属性是类对象共有的，所以可以用来统计一个类生产了多少个实例化对象
eclips快捷键
Alt+/ 自动联想
class Demo {
public Demo() {
System.out.println("2、构造方法。");
//定义构造方法
}
{System.out.println("1、构造块");} //定义构造块}
public class Test {
public static void main(String args[]) {
new Demo(); //实例化对象
new Demo();
new Demo();
}
}输出：
1、构造块
2、构造方法
1、构造块
2、构造方法
1、构造块
2、构造方法
可知构造块优先于构造方法执行，而且每次实例化对象时都会执行。
主方法所在类中的静态代码块优先主方法执行，类中定义的静态代码块优先于构造块执行，而且静态代码块只执行一次。
方法名相同，参数不同
Python使用位置参数，默认参数等处理
1、package & import
注意：
使用系统中的类同样需要import
java.lang包中的类可以直接使用，不需要导入
2、继承 extends
条件：A 是一种 B ， class A extends B
一旦继承，子类就自动拥有了父类中提供的成员变量以及方法
（构造方法除外）
注意： java只支持单继承
3、访问控制
| 修饰符 | 类本身 | 包中 | 继承 | 其他 |
|---|---|---|---|---|
| private | YES | NO | NO | NO |
| default/package | YES | YES | NO | NO |
| protected | YES | YES | YES | NO |
| public | YES | YES | YES | YES |
public 或者 default修饰类（内部类除外）
注意： 一个源文件中只能有一个 public 修饰的类，并且这个类要与源文件同名。但是可以多个默认修饰的类
4、方法的重写 override
前提：继承
注意：
重写的方法不能比被重写的方法有更严格的权限控制
重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型
5、super
super:表示父类对象的引用
super():表示在子类中调用父类的构造方法
注意：创建出子类对象，必须先创建出它的父类对象
当this与super在一起的时候，两个都要在第一行搞毛啊，所以让super()使用隐式调用就好。
a、当子类跟父类都没有可见的构造方法时
super();必须放在子类构造方法中第一行
b、如果子类中没有显性调用super（），默认调用父类中
无参的构造方法
c、如果子类中没有显性调用super（），父类中存在有参
的构造方法时，程序将出错
结合 this
6、对象转型
一个父类的引用类型变量可以“指向”其子类的对象。
一个父类的引用不可以访问其子类对象新增加的成员（变量，方法）
向上转型：父类引用指向之类对象
向下转型：必须要先向上转型
1、访问控制
get set方法
2、Object 如果一个类没有声明继承某个类，它就默认继承Object。
所有的类都是Object的子类
HashCode：方便查找
toString 有快捷方法
equals
注意：
a、如果两个对象相互equals，它们的hashCode肯定相同
b、如果它们的hashCode值相等，两对象不一定相等，此时
还需查看equals方法之后才能确认
c、重写equals一般都要重写hashCode
d、当两个对象equals后，它们的hashCode就相同了
e、hashCode()是一个快捷方式，比如比较10个对象，先比较它们的hashCode值，不同的直接pass，然后再用equals比较留下来的对象
3、多态（动态绑定，持绑定）
只有在运行时区判断对象的实际类型
多态存在的三个必要条件
a、要有继承
b、要有重写
c、要有父类声明指向子类实现 （向上转型）
4、抽象类 abstract
a、用abstract修饰的方法，成为抽象方法；
只有方法的声明，没有方法的实现
b、含有抽象方法的类必须声明为抽象类
c、抽象类就是给别人继承的
d、抽象类是一个残缺不全的类，不能实例化
e、抽象类除了有抽象方法之外，也还有普通方法
f、一个类继承了抽象类，必须重写抽象类中提供的抽象方法
或者将自身也声明为抽象类
类中定义构造块时无论如何必须在语句外加上{ }
内部类可直接访问外部类的私有属性。。。内部类的唯一好处就是可以方便地访问外部类的私有属性
使用static可以声明内部类，用static声明的内部类变成了外部类，但是用static声明的内部类不能访问非static的外部类属性。
ctrl + 1 ：系统提供解决方案
final的成员变量的值不能够被改变
final的方法不能够被重写
final的类不能够被继承
java继承的特性：java只支持单继承
接口是为了解决java中存在的语义上多继承
只有方法的定义（都是抽象方法）可以省略abstract
常量的定义（static final ）,可省略
访问权限都是public
接口跟类：
类 impimplements 接口
一个类可以实现多个接口
接口跟接口
接口 extends 接口
接口跟实现类之间存在多态性
使用接口？还是抽象类？
interface同时赋予了接口和抽象类的好处
优先使用接口
接口是单独存在的，必须放在单个文件里
注意：一个类实现多个不同的接口时，这些接口中尽量不要存在方法名相同的声明。
public class Outer {
int i = 100; //非静态的成员内部类:类的内部，方法的外部
class Inner { //可以使用private default protected public
public void setI(){
// 非静态的成员内部类可以访问外部类的成员变量
System.out.println("" + i);
}
}
public void getI(){}
public static void main(String[] args) {
// 要想创建内部类对象，必须要先有外部类对象
Outer outer = new Outer();
// 外部类对象.new 内部类
Inner inner = outer.new Inner();
inner.setI();
}
} public class Outer {
static int i = 100; // 静态的成员内部类:类的内部，方法的外部
static class Inner{
// 可以使用private default protected public
public void setI(){
// 静态的成员内部类只能访问外部类的静态的成员变量
System.out.println("" + i);
}
}
public void getI(){}
public static void main(String[] args) {
// 要想创建内部类对象，必须要先有外部类对象
Inner inner = new Outer.Inner();
// 因为是static的，使用 (类名.方法名)调用
inner.setI();
}
}public class Outer {
public void play(){
int j = 10;
class MyInner{
public void show(){
// 在局部内部类里面调用方法中局部变量
// 需要将局部变量声明为final(默认了）
// 或者声明为成员变量
System.out.println(j);
}
}
// 局部内部类只能在当前范围内使用
MyInner inner = new MyInner();
inner.show();
}
}public class Outer {
public static void main(String[] args) {
// Animal animal = new Animal();
// animal.jump();
Jumper jumper = new Jumper() {
@Override
public void jump() {
System.out.println("再也跳不动了");
}
};//整个括号里都是语句哦 jumper.jump();
}
}原文地址：http://jensen.blog.51cto.com/10505289/1676090
