近来的java小总结(2.1):类的知识的查漏补缺

首先,我是一名新手,所以,要带着批判的眼光来看下面的文章

  

 

这篇文章说了些什么?

这文章是我近来8.6号来在编程思想上打的代码,从0~200页的源码接近到在这里,下文正是总结这0~200页的的知识,涉及到接口,内部类.初始化,数值计算的一些细节.此文章不会一下子写完,可能隔一天可能再补下来.因为代码确实有点多..

注意

1 我的注释不一定正确(不过各小标题和代码一定是正确的,因为是书本上的原话,但是注释不一定正确),如果你确信我的内容的话,你可能会损失很大,因为我只是个菜鸟,我只是来补救一些知识的而已,如果不复制(最好自己打上)代码运行一次,可能会被我的在代码的注释所误解, 欢迎提意见和评论~~~你的意见和评论是我更新的动力(促进我更快滴读完编程思想)

本文适合读者

   适合有一定的编程基础的人,因为我的代码可能出错,建议零基础的人找本书先看看,或者一定要复制我的代码运行一下,否则,后果将不堪设想  <( ̄▽ ̄)> 哇哈哈…因为我也只是新手
  

再一次提醒

下面的注释只是我个人的总结.
我的注释不一定正确(不过各小标题和代码一定是正确的,因为是书本上的原话,但是注释不一定正确)
,但是注释的语序凌乱各种天花百草不说了.!!!!绝非书本原话!!!!所以要最好还是把我的代码复制下来,运行一遍,也可以把我的注释删掉,或者提示我说应该怎么说,应该怎么说.

再一次感谢

1 感谢你可以抽出你的时间来进行下面阅读,思考的碰撞是智慧产生的前提.谢谢你的阅读和你愿意复制我的代码并阅读我那千奇百怪无比丑的注释来进行思考的碰撞!~!~

正文:

1.默认构造器的产生时机

public class test{
    test (double i){

    }
    test (float i){

    }
    public static void main(String[] args) {
//        test a = new test();//报错
                test a = new test(3d);
               test b = new test(3f);
//    因为系统只会在没有定义构造器的时候
//自动生成默认构造器test(){} ,而现在已经定义了test(double i)
//就不会产生默认构造器,所以上面的注释会报错
    }
}

2.成员的初始化

boolean 值会被默认为true

int long short byte会自动默认为0,

而char 为一个空白键,就是空,

而double和float是0.0

引用数据类型,如String和各种类 初始化为null

 1 package thinkingInJava;
 2 public class InitialValues{
 3     public static void main(String[] args) {
 4         InitialValues iv = new InitialValues();
 5         iv.printInitialValues();
 6     }
 7
 8     boolean t;
 9     char c;
10     byte b;
11     short s;
12     int i;
13     long l;
14     float f;
15     double d;
16     String ss ;
17     InitialValues reference;
18     void printInitialValues(){
19                         //类中的变量会自动被初始化,并且 基本类型大部分都是0,浮点数大部分都是0.0
20                         //char 是 空一个格子,数值0     类大部分都是null;
21         System.out.println("data type  Initial value");
22         System.out.println("boolean    +"+t);
23         System.out.println("char    ["+c+"]");
24         System.out.println("byte    "+b+"");
25         System.out.println("short    "+s+"");
26         System.out.println("int    "+i+"");
27         System.out.println("long    "+l+"");
28         System.out.println("float    "+f+"");
29         System.out.println("Double    "+d+"");
30         System.out.println("String    "+ss+"");
31         System.out.println("Reference    "+reference+"");
32     }
33 }

3.可以用方法来对成员进行赋值

 1 public class testMehod{
 2         int i=f();
 3         int j  = f(i);
 4     int f() {int j = 3;return 11;};
 5                         //原来还可以这样做...  之前还认为在 方法外不能调用方法     这句话可能是正确的,但是赋值就打破了这一点.
 6                         //原来还可以直接运行方法体的..?
 7                         //从上到下读,并且还会追朔方法的吧?
 8     int f(int i){  return 22;}
 9     public static void main(String[] args) {
10
11     }
12 }

4.初始化的总结

1.初始化的时候,要看看
    1.该类有没有父类
1.1       1.1有    到父类
1.1   找static,static域初始化(static和static域的优先级是等同的,从上到下谁写在前就运行谁
1.1.*        (在这里也要注意的是,如果在static里面碰到了 new了一个对象)
1.1             会先不看static域的所有东西,而去在那对象里开始找定义和构造函数进行初始化),
阿里的面试题说明了这一点http://blog.csdn.net/ysjian_pingcx/article/details/19605335
1.2          到    子类
1.2   找static,static域初始化(也是从上到下读static和static域()}
1.3           再返回父类,在找定义语句和域语句{}进行初始化(也是优先级等同的,所以是从上到下)
1.4               再到父类的构造函数

1.5 再在到子类,在找定义语句和域语句{}进行初始化
1.6  再到子类的构造函数

  

 4. 1.定义初始化

 1 package thinkingInJava;
 2
 3
 4 public class testMehod{
 5         public static void main(String[] args) {
 6             House h = new House();
 7         }
 8 }
 9 class Window{
10     Window(int maker){
11         System.out.println("Window ("+maker+") ");
12     }
13 }
14 class House{
15     Window w1 = new Window(1);
16     House(){
17         w3 = new Window(33);
18     }
19     Window w2 = new Window(2);
20     void f(){
21         System.out.println("f()");
22     }
23     Window w3 = new Window(3);
24 }

4.2.静态初始化

package thinkingInJava;

            //要注意的是,main方法进行前还是先是进行类里面的static初始化,但是没有涉及
                //到的时候,是不会进行静态初始化的,不要认为static 在main外的类里面,就必须要先将他们读完
                //如果没用用到那个类的话,是不会初始化static的
public class testMehod{
    static Table table = new Table();
    static Cupboard cupboard = new Cupboard();
    public static void main(String[] args) {
        System.out.println("Creating new Cupboard() in main");
        new Cupboard();

        System.out.println("Creating new Cupboard() in main");
        new Cupboard();

        table.f2(1);
        cupboard.f3(1);

    }
}
class Table{
    static Bowl bowl1 = new Bowl(1);

    Table(){
        System.out.println("Table() ");
        bowl2.f1(1);
    }

    void f2(int marker){
        System.out.println("f2(" +marker +")");
    }

    static Bowl bowl2 = new Bowl(2);

}
class Cupboard{
    Bowl bowl3 = new Bowl(3);
    static Bowl bowl4 = new Bowl(4);

    Cupboard(){
        System.out.println("Cupboard()");
        bowl4.f1(2);
    }

    void f3(int marker){
        System.out.println("f3 ("+marker +") ");
    }

    static Bowl bowl5 = new Bowl(2);
}

class Bowl{
    Bowl (int marker){
        System.out.println("bowl ("+marker+")");
    }

    void f1(int marker){
        System.out.println("f1(    " +marker+")");
    }

}

4.3.普通员域初始化

package thinkingInJava;

public class Mugs{
        public static void main(String[] args) {
            System.out.println("Inside main()");
            new Mugs();

            System.out.println("new Musgs() completed    ");

            new Mugs(1);
            System.out.println("new Musgs(1) completed    ");
        }

        //fen jie xian------------------------
        Mugs(int i){
            System.out.println("Mug(int )");
        }
        Mugs(){
            System.out.println("Mugs()");

        }

        Mug mug1 ;
        Mug mug2;
        {
            mug1 = new Mug(1);
            mug2 = new Mug(2);
        }
}
class Mug{
    Mug(int marker){
        System.out.println("Mug ("+marker +")");
    }
    void f(int marker){
        System.out.println("f("+marker+")");
    }
}

5.enum类的知识

5.1.注意,test里面的类都是static final class

这里让我联系到了static内部类,内部类的知识就呈上来了

package thinkingInJava;

enum test{
	A,B,C,D;
}
public class OverLoading{
	public static void main(String[] args) {
		test a = test.A;
		System.out.println(a);  //enum 类重载了toString方法,直接打出
	}
}

5.1.1静态内部类

class A{ static class B{}}静态内部类用(外部类).(A)来直接创建对象 而   原来的非静态(class A { class B{}}内部类是依赖一个外部类来进行对象的创建,

   以下是静态内部类的例子.

package test.java;
public class Parcel11{
	public static class ParcelContents implements Contents
	{
		private int i=1;;
		public int value()			//普通的内部类是不能声明static方法的.我知道啊
		{
			return i;
		}
	}

	protected static class ParcelDestination implements Destination
	{
		private String label;
		private ParcelDestination(String whereTo)
		{
			label = whereTo;
		}

		public String readLabel()
		{
			return label;
		}

		public static void f(){}
		static int x = 10;

		static class AnotherLevel
		{
			public static void f(){}
			static int x =10;
		}
	}

	public static Destination destination (String s )
	{
		return new ParcelDestination(s);
	}

	public static Contents contents()
	{
		return new ParcelContents();
	}

	public static void main(String[] args) {
		Contents c = contents();			//  类里面嵌套static类 ,然后全部都变成static方法是搞那样
		Destination d = destination("ABC");  //这样子就完全不依赖内部类对象了, static类的话,只要一个上溯造型,就可以引出家了

	}

}

interface  Contents
{
	}
interface Destination
{
	}

  

 

 5.2  foreach 语法 来输出 enum ,  注意 test.values()

package thinkingInJava;

enum test{
	A,B,C,D;
}
public class OverLoading{
	public static void main(String[] args) {

		for (test temp:test.values()){   //要注意test.values() 就好像 一个数组名一样  for (  变量: 数组)
		System.out.print(temp+" ");  //enum 类重载了toString方法,直接打出
		System.out.println(temp.ordinal());  // 输出他的序号,用来case不错.
		}
	}
}

  

5.3用switch来最实用滴调用enum

package thinkingInJava;
enum testA{
	A,B,C,D;
}

public class Burrito{
			//这个另我领悟了包的重要性...因为不小心重叠了一些类的名字,莫名的报错,打包了之后就没有这些错的发生了
	public static void main(String[] args) {
		Burrito plain = new Burrito(testA.A),
		greenChile = new Burrito(testA.B),
			jalapeno = new Burrito(testA.C);

		plain.decribe();
		greenChile.decribe();
		jalapeno.decribe();
	}

	// 方法区和变量区
	testA degree;
	public Burrito(testA degree){
		this.degree = degree;   //可以设置一个 enum变量
												//然后用 switch 来得到相应的描述
	}
	public void decribe(){
		System.out.println("This burrito is ");
		switch(degree){
		case A:
			System.out.println("A");
			break;
		case B:
			System.out.println("B");
			break;
		case C:
			System.out.println("C");
			break;
		case D:
			System.out.println("D");
			break;
		default:
			System.out.println("maybe hot ");
			break;
		}
	}
}

  6.引用static类来创建自己的工具库

  

package net.mindview.util;
  //下次用的时候直接诶用 import static net.mindview.util.Print.*;   //你会稳为什么要import static ,因为他是导入静态方法  //你也会稳为什么导入 improt static net.mindview.util.*;为什么会报错  //因为import static只能导入全部都是静态方法的语句
import java.io.PrintStream;

public class Print{
		public static void print(Object obj){
			System.out.println(obj);
		}		//打印一个信行  这样之后就不用换行了

		public static void print(){
			System.out.println();
		}

		public static void printnb(Object obj){
			System.out.print(obj);
		}

		public static PrintStream printf(String format,Object...args){
			return System.out.printf(format,args);  //这个用来干吗的,  new javaSE5 printf FROM C;

		}

}

*********************************
测试
package thinkingInJava; 

import static net.mindview.util.Print.*;   //全部静态方法的导入

public class PrintTest{
	public static void main(String[] args) {
		print("新的方法啊.,爽爆了");
		print(100);
		print(100L);
		print(3.14159);
	}
}

package net.mindview.util;
public class Range{
	public static int[] range(int n){
		int[] result = new int[n];
		for ( int i =0 ; i<n ; i++){
			result[i] = i;
		}
		return result;
		  //创建工具去返回一个  result数组,
	}

	public static int[] range(int start,int end){
		int sz = end-start;
		int[] result = new int[sz];
		for ( int i=0 ; i <sz ; i++){
			result[i] = start+i;
		}
		return result;
					//返回一个范围数组
	}

	public static int[] range(int start,int end,int step){
		int sz = (end-start)/step;
		int[] result = new int[sz];
		for ( int i=0; i <sz ; i++){
			result[i] = start+(i*step);
		}
						//返回一个1,3,5,7的数组
		return result;
	}
}

  

另外补充..finalize的备用

System.gc()(在运行程序的时候,该函数不一定会运行)会自动调用finalize() 方法,该方法是用户手动清理对象的函数

package thinkingInJava;

public class terminationCondition{
    public static void main(String[] args) {
        Book novel = new Book(true);
        //Proper cleanup
        novel.checkIn();

        //Drop the reference,forget to lean up:
        new Book(true);

        //Force garabage collection & finalization:
        System.gc();
    }

}

class Book{
    boolean checkOut = false;
    Book(boolean checkOut){
        checkOut = checkOut;
    }
    void checkIn(){
        checkOut = false;
    }

    protected void finalize(){
        System.out.println("abc");
        if ( checkOut){
            System.out.println("Error : check out");
            //也可用 super finalize()
        }
    }
}

近来的java小总结(2.1):类的知识的查漏补缺,布布扣,bubuko.com

时间: 08-11

近来的java小总结(2.1):类的知识的查漏补缺的相关文章

近来的java小总结(2.2):类的知识的查漏补缺

1 首先,我是一名新手,所以,要带着批判的眼光来看下面的文章   这篇文章说了些什么? 这文章是我近来8.6号来在编程思想上打的代码,从0~200页的源码接近到在这里,下文正是总结这0~200页的的知识,涉及到接口,内部类.初始化,数值计算的一些细节.此文章不会一下子写完,可能隔一天可能再补下来.因为代码确实有点多.. 注意 1 我的注释不一定正确(不过各小标题和代码一定是正确的,因为是书本上的原话,但是注释不一定正确),如果你确信我的内容的话,你可能会损失很大,因为我只是个菜鸟,我只是来补救一

自家用的java小总结(2.4):类的知识的查漏补缺(内部类)

1 2      首先,这是一篇自己用的文章,不对读者承担任何责任,所以,要带着批判的眼光来看下面的文章   1 发现了,得加上输出结果,怕自己出错,~~   这篇文章说了些什么? 这文章是我近来8.6号来在编程思想上打的代码,从0~200页的源码接近到在这里,下文正是总结这0~200页的的知识,涉及到接口,内部类.初始化,数值计算的一些细节.此文章不会一下子写完,可能隔一天可能再补下来.因为代码确实有点多.. 注意 1 我的注释不一定正确(不过各小标题和代码一定是正确的,因为是书本上的原话,但

查漏补缺——java多态

---恢复内容开始--- 刚学完java,开始了查漏补缺阶段阶段,为了巩固自己的知识和为别人提供一些微末的帮助决定开通博客,求各位大牛们指出我的不足,不要吝惜言语,也希望我的总结可以对别人有帮助,对自己对他人负责. 开始正文:术语多态:可以定义为“有多种形态”,多态引用是一个一个在不同时刻可以指向不同类型对象的引用变量.通过多态引用可以调用不同的具体的方法. 类方法的多态性的实现有两种方式: 1:方法重载:可以声明多个同名但是参数不同(个数.类型和顺序)的方法.注意呵呵重载方法只能声明在一个类里

java知识查漏补缺

一.重写(override)和重载(overload)的区别 二者除了名字相似,其实没什么联系 范围不同:重写发生在同一个类的不同方法之间.重载发生在父类和子类自荐. 前提: 重写要求:方法名相同,参数列表不同,对于返回值类型不要求相同. 重载要求:方法名形同,参数列表也相同.重载是实现多态的关键,注意如果父类中的方法是private类型,那么子类中对应方法不算重载,而相当于是定义了一个新方法. 二.final的用法 修饰类:该类不能被继承 修饰方法:该方法不能被重写 修饰属性:该属性初始化后不

查漏补缺(java)

一.匿名数组: Java中提供一种创建数组对象并同时赋予初始值的简化书写形式 int[] a = {1,2,5,4}; 在不创建新变量的情况下,重新初始化一个数组 int b[] = {1,2,3,4}; a = b; 简化:a = new int[]{1,2,3,4}; 详见代码: public class Main { public static void main(String[] args) { //匿名数组的定义方式new int[]{1,5,1,9} int a[] = {1,5,1

查漏补缺——java枚举(enum)

刚学完java,为了巩固自己的知识和为别人提供一些微末的帮助决定开通博客,求各位大牛们指出我的错误,也希望我的总结可以对别人有帮助. enum的全称是enumeration,是JDK1.5引入的新特性,同时”泛型“也是这一阶段,下一次总结. 1.为什么要创建枚举类型? 答:在编程过程中经常可以遇见数据稳定而且有限的一组数据,比如四季{春,夏,秋,冬}: 而当我们选择一个季节的时候只能四季四个值里选择一个,所以枚举类型是类型安全的,如果使用顶以外的值会编译出错.(例子) package based

Java小案例(行星移动)

Java小案例 行星移动:参考:三百集 使用软件:idea2017,java 1,图片集:这里  (idea图片源放在target目录下,才能访问到),建议从小往上看... 2,定义MyFrame package my.university; import java.awt.*; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; public class MyFrame extends Frame {

java中常用的工具类(二)

下面继续分享java中常用的一些工具类,希望给大家带来帮助! 1.FtpUtil Java 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

Java线程示例 - 继承Thread类和实现Runnable接口

进程(Process)和线程(Thread)是程序运行的两个基本单元.Java并发编程更多的是和线程相关. 进程 进程是一个独立的执行单元,可将其视为一个程序或应用.然而,一个程序内部同事还包含多个进程.Java运行时环境就是一个单独的进程,在它内部还包含了作为进程的各种类和程序. 线程 可以将线程看做轻量级的进程.线程存在于进程当中,需要的资源开销较小.同一进程中的线程共享进程的资源. Java多线程 每一个Java引用都只要有一个线程 - 主线程(main thread).虽然后台还运行着许