发表于： 2017-03-11 11:28:36
5 1854
PS:因为是先在博客园上写的，这边的一些格式可能不支持，所以有些图片和代码没有显示，下面会附上完整博客链接的
一：上午完成
上午详细了解了java面向对象编程的一些细节，记录如下。
1）类
是一种引用类型，包含一个签名和一个主体，主体是放在花括号里面的成员，成员包括字段和方法，还有构造方法、初始化程序和嵌套类型。
常用成员有四种：类字段、类方法、实例字段、实力方法。
其它引用类型还包括数组、接口、枚举和注解。
2）字段和方法
示例：一个简单的类和成员（代码）
还有就是this的使用，它竟然是一个隐式参数！第一次知道，，也可能是我之前没留意。意义是“在当前对象上调用实例方法”。
3）创建和初始化对象
构造方法看作是类成员，可以定义多个构造方法，只要参数列表不一样就行。在一个构造方法中也可以调用其它构造方法，可以避免大量的初始化代码。
4）子类和继承
对于super关键字，需要了解的是：在子类中调用超类构造方法时必须在第一个语句中调用。代码如下
这里面涉及到构造方法链，就是创建对象时的一系列构造方法，从子类到顶端的Object类为止。
如何引用被遮盖的字段？把this（或 类的实例）矫正为适当的超类，然后再访问字段。
例如有三个类A、B和C。它们都定义了一个x的字段，并且C是B子类，B是A子类，那么，在C中可以这样
代码如下
还需要分清方法覆盖和字段遮盖。
注意调用覆盖方法时的super和调用超类时的super用法是不一样的。
5）数据隐藏和封装
java的包不能“嵌套”，比如java.A.a和java.A是不同的包
对于访问控制和继承，图片如下
总结了一下成员访问规则，图片如下
对于有些数据访问器方法（getter，setter），需要记住的是，public方法访问字段可以进行检查。
6）抽象类和方法
有些抽象类可以没有任何抽象方法，比如classLoder（这个底层类貌似很牛）。
示例代码：一个抽象类和两个具体类
对象之间也可以发生转换，分为放大和缩小转换
数组转换规则只适用由对象或数组 组成的数组，基本类型的数组不能转换。
二：下午计划
看完并记录java类型系统这一章，有时间的话开始做那个任务一的第一个板块
三：遇到问题
为什么感觉平时写代码没有感觉到有这么多的知识点？是没用到吗？还是自己缺少思考？
四：收获感悟
相对于其它面向对象的语言，java真可以说的上是入门首选，即便它有时候会显得啰嗦一点，但是严格的语法和句法要求对于初学者来说是必要的。
这次试试修真院的编辑器！
一：下午完成
主要看了java的类型系统，具体如下。
1）接口
作为又一个引用类型，接口可以说是一种特殊的类，可以有属性和行为（字段和方法），但是都是受限的。
不过java8里面倒是加了新功能，可以使用默认方法。
对于接口中的强制方法（抽象方法），子类必须全部实现。
对于默认方法觉得有必要举个例子。
java.util.List接口中有一个sort（）默认方法，定义如下。
interface list<E>{
publi default void sort(Comparator <? super E> c ){//其实这个方法有些不太理解
Collections.<E>sort(this,c);
}
}
还有一种是全空的标记接口，不需要在子类中实现任何方法，主要是方便将类的实例作为接口的有效实例，比如java.io.serializable接口，就是声明这个类的实例可以安全序列化（貌似是一种转换机制）。
2）java泛型
容器类型一般叫做泛型：
interface Box<T>{
void box (T t);
T unbox();
}
使用泛型可以增强程序的安全性——编译时会检查类型错误
<T> 还有个名字叫参数类型，参数类型始终是引用类型，它的值不能使用基本类型。
在java中使用菱形句法可以省略重复的类型值：List<CerteredCircle> shapes = new ArrayList<>();
非泛型的List一般叫做原始类型（就是比较low了）
参数化类型也不能实例化，比如ArrayList<T>,但是编译时也需要了解这是什么类型，怎么办呢？使用通配<?>
ArrayList<?> mysteryList = unknowList():
Object o = mysteryList.get(0);
java语言是禁止实例化负载为未知类型的容器类型，比如List<?> unknows = new ArrayList<?>();
还有合法的List<?> objets = new ArrayList<String>();
这表明，List<String>是List<?>的子类型。但是List<?>都不是List<T>子类型。
还有就是类型变体（有点抽象），举个例子就是List<cat>是List<? extends pet>子类型，因为List是Cat对象的制造者。
可以理解为PECS原则（制造者使用extends，使用者使用super）
作为java泛型的使用者，我们需要理解类型擦除（有点难理解）的基本知识，特别是运行时对泛型的处理方式。
这里再说一下编译时和运行时的一些差别，就是对比javac和JVM的区别。
List<String> l = new ArrayList<>();
System.out.println(l);
究竟有什么不同呢？可以想一下 l 的类型，结果是编译和运行两个阶段是不一样的。javac把l 看作List-of-String类型，会依照这个检查句法错误。
而jvm 呢，把l看成是ArrayList类型的对象，还因为要擦除类型，所以运行时l是原始类型（，，自己都有点糊涂了）
3）枚举和注解
这个还是举个例子更清楚：
枚举：
public enum RegularPolygon{
TRIANGLE(3),SQUARE(4);
private Shape shape;
public Shape getShape(){
rerurn shape;
}
private RegularPolygon(int sides){
switch(sides){
case 3:shape = new Triangle(1,1,1,60,60,60);//边长和角度
break;
case 4:
shape = new Rectangle(1,1);
break;
}
}
}
需要说明的是枚举实例是由java运行时创建的，在外部不能实例化，所以将构造方法声明为私有方法。
注解：（是一种特殊的接口）
常用的有@Override，@Deprecated,@SuppressWarnings,@SafeVarargs（变长参数方法提供警告静默），@FunctionInterface。
还有自定义注解，就是使用元注解@Target，@Retention。
看一个示例
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Nickname{
String[] value() default {} ;
}
二：晚上计划
将剩余的两个知识点看完，嵌套类型和lambda表达式
三：遇到问题
有些知识点即使看过了还是不能充分理解，大概这就是看书的局限性吧
四：收获感悟
对于java8的lambda表达式，自己一直都是只闻其名，没有真正了解和使用过，这次要弥补这个缺憾。
分割线----------------------------------------------------------------------------------------
- 一：晚上完成
- 4）嵌套类型
- 先说一下自己对国外的翻译书籍《java技术手册》和国内著名博客的粗浅理解
- B 而国内的博客文章就是春风化雨了，在国人普遍逻辑上尽可能以一种方便理解的视角去解读知识点，让你很快的就熟悉并掌握，不多涉及底层。
- C 只能说两者各有特点吧，与我而言，还是看博客更爽一点，等理解了再去翻看国外的技术书籍估计会有另外的收获
- 大神就是大神，代码境界真的是甩我几条街，我就不献丑了，也是为了大家能看懂。
- 再说说顶层类型有哪些（类、接口、枚举），它们都是包的直接成员。
引入嵌套的目的：深入访问另一个类型的内部实现；在特定情况下使用某个类型。
有四种类型（不能简单的说是内部类或是匿名类，因为不能说静态成员类型是内部类），静态成员类型、非静态成员类型、局部类、匿名类。
/**
* 四种不同类型的内部类
* @author Administrator
*
*/
public class OuterOfInnerClass {
int out_x = 0;
public void method() {
Inner1 inner1 = new Inner1();
final int a = -1;
//在方法体内部定义的内部类,只允许使用抽象或终态
/**
* 局部内部类
*
*/
class Inner2 {
public void method() {
out_x = 3;
System.out.println(a);
}
}
Inner2 inner2 = new Inner2();
}
/**
*成员内部类 Inner Class
*
*/
public class Inner1 {
}
/**
* 静态内部类 Static Nested Class
*
*/
public static class Inner3 {
int a = new OuterOfInnerClass().out_x;
public void aa() {
}
}public ParentAbstract rr() {
/**
* 匿名内部类
*/
return new ParentAbstract() {
void save() {
}
};
}
public void testInner1() {
int b = 1;
OuterOfInnerClass oo = new OuterOfInnerClass();
OuterOfInnerClass.Inner1 inner1 = oo.new Inner1();
}}
abstract class ParentAbstract {
abstract void save();
}
5）：lambda表达式
听说，lambda表达式的很多功能都能使用嵌套类通过回调和处理程序等模式实现（我是没有见过）
有些人喜欢把lambda表达式当成“匿名方法”（是吗？）
做一个简单的对比吧。
A 使用匿名类定义一个FilenameFilter类，列出后缀是.java的文件
File dir = new File("/src");
String[] filelist = dir.list(new FilenameFilter(){
public boolean accept(File f, String s)
return s.endWith(".java");
}
} );
B 使用lambda表达式，上述代码可以简化为：
File dir = new File("/src");
String [] filelist = dir.list((f,s) -> {return s.endwith(".java");});
天呐，这真是太方便了！！！
C 因为可以把lambda表达式看成是没有名称的方法，所以可以这样使用：（Myobject myObj） -> myObj.toString()
java8提供了一种句法可以更方便
MyObject::toString 哈哈，真的是简洁
D 函数式编程有一个共识：把函数当成值，存入变量
对于java开发者刚开始接触的话建议使用这三个基本习语map() filter() reduce()
但是还是要记得java没有结构类型，没有“真正的”函数类型
二：明天计划
只是看书的话某些语法知识点还是理解的不透彻，还是找点做项目实战吧
三：遇到问题
希望可以见到更多使用内部类的代码，看看真正这种东西是用在那些地方的
四：总结思考
感觉这样翻看知识点效率有点低，没有针对性，还是 “做中学” 吧
返回列表
评论