自家用的java小总结(2.2):类的知识的查漏补缺
|
1
|
首先,这是一篇自己备用的文章,所以,要带着批判的眼光来看下面的文章 |
这篇文章说了些什么?
这文章是我近来8.6号来在编程思想上打的代码,从0~200页的源码接近到在这里,下文正是总结这0~200页的的知识,涉及到接口,内部类.初始化,数值计算的一些细节.此文章不会一下子写完,可能隔一天可能再补下来.因为代码确实有点多..
注意
1 我的注释不一定正确(不过各小标题和代码一定是正确的,因为是书本上的原话,但是注释不一定正确),如果你确信我的内容的话,你可能会损失很大,因为我只是个菜鸟,我只是来补救一些知识的而已,如果不复制(最好自己打上)代码运行一次,可能会被我的在代码的注释所误解, 欢迎提意见和评论~~~你的意见和评论是我更新的动力(促进我更快滴读完编程思想)
本文适合读者
适合有一定的编程基础的人,因为我的代码可能出错,建议零基础的人找本书先看看,或者一定要复制我的代码运行一下,否则,后果将不堪设想 <(￣▽￣)> 哇哈哈…因为我也只是新手
再一次提醒
下面的注释只是我个人的总结.
我的注释不一定正确(不过各小标题和代码一定是正确的,因为是书本上的原话,但是注释不一定正确)
,但是注释的语序凌乱各种天花百草不说了.!!!!绝非书本原话!!!!所以要最好还是把我的代码复制下来,运行一遍,也可以把我的注释删掉,或者提示我说应该怎么说,应该怎么说.
再一次感谢
1 感谢你可以抽出你的时间来进行下面阅读,思考的碰撞是智慧产生的前提.谢谢你的阅读和你愿意复制我的代码并阅读我那千奇百怪无比丑的注释来进行思考的碰撞!~!~
正文:
1.包的访问权限
对象 同一个类 同一个包 不同包的子类 不同包的非子类 private关键字 可以 缺省关键字 可以 可以 (default) protected关键字 可以 可以 可以 public关键字 可以 可以 可以 可以
package access.dessert;;
public class Dinner{
public static void main(String[] args) {
Cookie x = new Cookie();
x.bite(); // 缺省值包内的东西都是另一个包的东西都不能访问
//同包内能访问. 并且注意, package 不用到具体位置
}
}
package access.dessert;
public class Cookie{
public Cookie(){
System.out.println("Cookie constructor!");
}
void bite(){
System.out.println("bite");
}
}
2.当不想别人随便new一个对象的时候
package access.dessert;
//通道走到private
class Sundae{
private Sundae(){}
static Sundae makeASunDae(){
return new Sundae();
}
}
public class IceCream{
public static void main(String[] args) {
// Sundae x= new Sunade(); //不能访问private 的构造器
Sundae x = Sundae.makeASunDae();
}
}
3.测试protected
//测试 protected
package testjava;
import access.dessert.*;
public class ChocolateChip extends Cookie{
public static void main(String[] args) {
ChocolateChip x = new ChocolateChip ();
x.chomp();
}
public void chomp(){
bite(); //bite方法在另外的包里,
}
}
4.用组合来尝试
import static net.mindview.util.Print.*;
//静态导入的 时候,一定会有 1.静态方法2.并且要具体到类
public class Bath {
public static void main(String[] args) {
Bath b = new Bath();
print(b);
}
//方法和变量区
private String s1 = "happy" , s2 = "happy" ,s3,s4;
private Soap castile; //组合类的语法而已嘛...
private int i;
private float toy;
public Bath(){
print("Inside Bath()");
s3 = "toy";
toy = 3.14f;
castile = new Soap(); //可以通过 toString()方法来调用这个new吗?才能达到赋值?
}
{
i=47;
}
public String toString(){
if ( s4== null)
s4="toy";
return
"s1 = "+s1+"\n"+
"s2 = "+s2 +"\n"+
"s3 =" +s3 +"\n"+
"s4 = " +s4+"\n"+
"i =" +i +"\n"+
"toy = " + toy +"\n"+
"castile = " +castile;
}
}
class Soap{
private String s ;
Soap(){
print("Soap()");
s = "constructed";
}
public String toString(){ return s;};
}
4.隐藏和覆盖有什么区别??
隐藏是不是就是继承于父类但是在子类里没有明显得声明
import static net.mindview.util.Print.*;
public class Hide{
public static void main(String[] args) {
Bart b = new Bart();
b.doh(1);
b.doh('x');
b.doh(1.0f);
b.doh(new MilHouse());
}
}
class Homer{
char doh(char c){
print("doh(char) ");
return 'd';
}
float doh(float f){
print("(doh(float)");
return 1.9f;
}
}
class MilHouse{};
class Bart extends Homer{
void doh(MilHouse m ){ //这个是覆盖?还是隐藏,应该是隐藏吧 还有就是,如果你想写覆盖方法的时候 @Override参数
print("doh(MilHouse");
}
}
5.可调用继承的函数
注意继承的时候如果父类有构造函数非空的情况,一定要用super(参数)来初始化构造函数
package testjava;
import static net.mindview.util.Print.*;
public class Orc extends Villian{
public static void main(String[] args) {
Orc orc = new Orc("Limburger",12);
print(orc);
orc.change ("Bob",19);
print(orc);
}
//方法区和变量区
private int orcNumber;
public Orc (String name,int orcNumber){
super(name);
this.orcNumber = orcNumber;
}
public void change(String name,int orcNumber){
set(name); //因为继承,所以可以调用 意思就是父类的一个方法,可以直接在子类的函数里调用
this.orcNumber = orcNumber;
}
public String toString(){
return "Orc" +orcNumber +":"+super.toString();
}
}
class Villian{
private String name;
protected void set(String nm){ name = nm;}
public Villian(String name){ this.name =name ;}
public String toString(){
return " I' a villain and my name is "+name;
}
}
6.向上转型(运用多态的一种非常重要的手法)
package testjava;
import static net.mindview.util.Print.*;
class Instrument{
public void play(){
System.out.println("play");
}
static void tune(Instrument i){
i.play();
}
}
public class Wind extends Instrument{
public static void main(String[] args) {
Wind flute = new Wind();
Wind.tune(flute);
}
}
7.final的知识点总结
等等 final关键字 有几种情况 (注意类里面 private的东西会被自动添加final关键字
(但是,初始化的时候,不会认为有final所以优先初始化,) 1.修饰函数, 对子类不可看见,但是对于该类的对象可以引用 2.修饰基本数据类型 值不可以被改变 3.修饰引用数据类型 指向不可以被改变 4.修饰函数参数 在函数内部的 值不可以被改变 指向不可被改变 5.修饰构造器. 也没见过(不可以用final 修饰构造器,构造器只能是public ->protected ->private 6.修饰类 不可被继承
package testjava;
import static net.mindview.util.Print.*;
import java.util.*;
class Value{
int i;
public Value(int i){
this.i = i;
}
}
public class FinalData{
private static Random rand = new Random(47);
private String id;
public FinalData(String id){
this.id = id;
}
//static final的于要用大写
//编译时的常量
private final int valueOne= 9;
private static final int VALUE_TWO=99;
//类型公共常量
public static final int VALUE_THREE=39;
//不会编译的常量
private final int i4 = rand.nextInt(20);
static final int INT_5=rand.nextInt(20);
private Value v1 = new Value(11);
private final Value v2 = new Value(22);
private static final Value VAL_3 = new Value(33);
//数组
private final int[] a={1,2,3,4,5,6};
public String toString(){
return id+":" +"i4 = " +i4 +", INT_5 = "+INT_5;
}
public static void main(String[] args) {
FinalData fd1 = new FinalData("fd1");
//不可以改变 Final的值
// fd1.valueOnt++;; private final int
fd1.v2.i++; //这个操控的是 final Value v2 可以改变他的i值
fd1.v1 = new Value(9); // 这个没什么好说的
for ( int i =0 ; i<fd1.a.length ; i++){
fd1.a[i]++; // 在对象里面 final int[] a 可以修改? a[] 是final int 类型
}
// fd1.v2 = new Value(0); 不可以再给final class 一个新的构造函数,但可以改变他的内部
// fd1.VAL_3 = new Value(1); static final 也是不行的
// fd1.a = new int[3]; 不可以给他创建一个新的指向对象... 哦 要记住,那是对象,不是基本类型,基本类型可改~
//引用指向和基本类型指向要区分
//java 里面 final a[] 是一个指针, 里面的内容是可以改变的. 但是final的指向不能改变
print(fd1);
print("Creating new FinalData");
FinalData fd2 = new FinalData("fd2");
print(fd1);
print(fd2);
}
}
package testjava;
import static net.mindview.util.Print.*;
import java.util.*;
class Poppet{
private int i;
Poppet(int ii){
i=ii;
}
}
public class BlankFinal{
private final int i=0;
private final int j; //一定要被初始化, 如果 final变量 ...非final变量会自动初始化
private final Poppet p ;
// public BlankFinal(){
// j = 1;
// p = new Poppet(1);
// }
// public BlankFinal(int x){
// j = x;
// p = new Poppet(x); //吃石化fianl
// }
public static void main(String[] args) {
print(new BlankFinal().j);
// new BlankFinal(47);
}
}
package testjava;
import static net.mindview.util.Print.*;
import java.util.*;
class Gizmo{
public void spin(){}
}
public class FinalArguments{
void with(final Gizmo g){
// g = new Gizmo();
}
void without(Gizmo g){
g= new Gizmo();
g.spin();
}
static int g(final int i){
return i+1; //可以通过值传递,但是不能被赋值.
}
public static void main(String[] args) {
FinalArguments bf = new FinalArguments();
bf.without(null);
bf.with(null);
int i=3;
i = g(4);
print(i);
}
}
package testjava;
import static net.mindview.util.Print.*;
import java.util.*;
//private 是一些隐藏的代码
//private 都
class WithFinals{
private final void f(){
print("WIthFInals.f()");
}
private void g() {
print("WithFinals.g()");
}
}
class OverridingPrivate extends WithFinals{
private void f(){
print("OverridingPrivate.f()");
}
private final void g(){ //说明这private 对于其他类是隐藏的,
//因为把他变成protected private ,是不能覆盖的.
print("OverRiding private.g()");
}
}
class OverridingPrivate2 extends OverridingPrivate{
public final void f(){
print("2~Overrdingprivate f()");
}
public void g(){
print("2~OverrdingPrivate.g()");
}
}
public class FinalOverridingIllusion{
public static void main(String[] args) {
OverridingPrivate2 op2 = new OverridingPrivate2();
op2.f();
op2.g();
OverridingPrivate op = op2; //子类赋值给父类
op.f(); //继承就不能用了. //那么那个final究竟有什么意味?
op.g(); //这里还要注意的 private ->private final;是首先扫描的.
//而protected public 是不扫描,编译器初始化时不会涉及到protected 和public
WithFinals wf = op2; //子类赋值给父类, 向上造型啊
wf.f();
// wf.g();
}
}
package testjava;
import static net.mindview.util.Print.*;
import java.util.*;
//private 是一些隐藏的代码
//private 都
class WithFinals{
private final void f(){
print("WIthFInals.f()");
}
private void g() {
print("WithFinals.g()");
}
}
class OverridingPrivate extends WithFinals{
private void f(){
print("OverridingPrivate.f()");
}
private final void g(){ //说明这private 对于其他类是隐藏的,
//因为把他变成protected private ,是不能覆盖的.
print("OverRiding private.g()");
}
}
class OverridingPrivate2 extends OverridingPrivate{
public final void f(){
print("2~Overrdingprivate f()");
}
public void g(){
print("2~OverrdingPrivate.g()");
}
}
public class FinalOverridingIllusion{
public static void main(String[] args) {
OverridingPrivate2 op2 = new OverridingPrivate2();
op2.f();
op2.g();
OverridingPrivate op = op2; //子类赋值给父类
op.f(); //继承就不能用了. //那么那个final究竟有什么意味?
op.g(); //这里还要注意的 private ->private final;是首先扫描的.
//而protected public 是不扫描,编译器初始化时不会涉及到protected 和public
WithFinals wf = op2; //子类赋值给父类, 向上造型啊
wf.f();
// wf.g();
}
}
