《疯狂Java讲义》读书笔记1

这个题挺难写的，直接用 bfs 肯定做不出来，还涉及了很多其他没有学过的知识点，所以写了一篇题解。 

简单搜索&&进阶搜索 - Virtual Judge (vjudge.net)

http://t.csdn.cn/8VlU4

对于 java 学习还有很多漏洞，之前是看视频学习的，所以很多东西没有学到，很多名词还不了解。

上周的答辩我觉得很有意义，我发现和其他人的差距还很大，在学 java 和做项目这个计划上面我落后很多了，所以我要花更多时间看书，先看书到时候学完再复习视频的知识。

这两天学习 java 是看的书，刚开始看的时候，它这么厚真的很劝退，但是我发现仔细看里面的内容，他讲的真的很好，是视频里面达不到的效果，这就是学长学姐给我们每人一本书，让我们看的原因，有时候视频看一遍就过去了，有些概念可能是模糊的，然后就会很快忘记。

即使是看书理解了，但是去敲代码会发现，很多地方没有考虑到，要理解然后到代码实现。

变量：

静态变量：在类加载的时候分配空间以及赋值的，无需创建对象，只要加载了，这个变量就存在，可以供类内所用方法调用。随着类的加载而加载，随着类的消失而消失。

实例变量：随着对象的创建而存在，随着对象的回收而释放。

方法：

类方法：随着类的创建就存在。

实例方法：只有在对象实例化之后存在。

这两天看了面向对象中的封装，很多都是前一周学习的时候不知道的，学习笔记我写了一些重点的：

Person 类和 PersonTest 类：

//里面没有定义构造器，但系统默认为它提供一个构造器
package com.ittht.day02;

public class Person {
    public String name;
    public int age;
    public void say(String content)
    {
        System.out.println(content);
    }

}

package com.ittht.day02;

public class PersonTest {

    Person p=new Person();//通过new关键字调用Person类的构造器，返回一个Person的实例

//    var p=new Person;/*用var定义该变量*/

//    Person P;
//    P=new Person();/*先定义再将该Person实例赋值

    public void fun() {
        p.name = "李刚";
        p.say("Java 语言很简单，学习很容易!");
        System.out.println(p.name);
    }
    public static void main(String[] args){
        var k=new PersonTest();
        k.fun();
    }
}

 Varargs 类：（形参可变的方法）

package com.ittht.day02;
//形参个数可变的方法
public class Varargs {
    public static void test(int a,String...books){
        for(String tmp:books)//与下面等价（强化循环）
        {
            System.out.println(tmp);
        }
//        for(int i=0;i<books.length;i++)
//        {
//            String tem=books[i];
//            System.out.println(tem);
//        }
        System.out.println(a);
    }
    public static void main(String[]args){
        test(5,"1222","2333","34324");
    }
}

 

 Dog 类和 DogTest 类（this 的使用）

//this访问该类的另一个方法或者实例变量
package com.ittht.day02;
public class Dog {
    public void jump(){
        System.out.println("执行jump方法");
    }
    public void run(){
//        Dog dog=new Dog();
//        dog.jump();/*第一种写法*/
        this.jump();/*第二种写法*/
//        jump();/*第三种写法（在同一类内，非静态的方法调用其他方法可以省略this）*/
        System.out.println("执行run方法");
    }
}

package com.ittht.day02;

public class DogTest {
    public static void main(String[] args){
        Dog dog=new Dog();//创建Dog对象：dog
        //调用jump方法和run方法
        dog.jump();
        dog.run();
    }
}

ReturnThis 类（return this 的使用） 

//return this 的使用
package com.ittht.day02;

public class ReturnThis {
    public int age=5;
    public ReturnThis grow(){
        age++;
        return this;//用return this可以连续调用这个方法
    }
    public static void main(String[] args){
        ReturnThis rt=new ReturnThis();
        rt.grow()
                .grow()
                .grow();//调用三次
        System.out.println("rt的age的值："+rt.age);
    }
}

ThisInConstructor 类（ this 也可以用在构造器中作为默认引用）

 

StaticAccessNonStatic 类：（静态方法和非静态方法）

package com.ittht.day02;
//静态方法（用static修饰）不能直接访问非静态方法（没有用static修饰）
public class StaticAccessNonStatic {
    public void foo(){
        System.out.println("简单的foo方法");
    }
    public static void main(String[] args){
        new StaticAccessNonStatic().foo();//创建一个对象
    }
}

Overload 类 ：（方法重载）

//方法重载：两个以上的方法名相同，形参列表不同
package com.ittht.day02;

public class Overload {

    //定义两种test方法，系统能分辨出来
    public void test(){
        System.out.println("无参数");
    }
    public void test(String msg){
        System.out.println("重载的test方法:"+msg);
    }

    public static void main(String[] args) {
        Overload ol=new Overload();
        ol.test();
        ol.test("a b c d");
    }
}

递归方法：

满足f(0)=1,f(1)=4...f(n+2)=2*f(n+1）+f(n)

package com.ittht.day02;
//f(0)=1,f(1)=4...f(n+2)=2*f(n+1）+f(n)
public class Recursive {
    public static int fn(int n){
        if(n==0)
            return 1;
        else if(n==1)
            return 4;
        else
            return 2*fn(n-1)+fn(n-2);
    }

    public static void main(String[] args) {
        System.out.println(fn(10));
    }
}

 

 

 Personlei 和PersonTest1 类：（setter和getter用法）

package com.ittht.day03;

//用private修饰成员变量，将这些成员变量隐藏起来
public class Person1{
    private String name;
    private int age;
    public void setAge(int age){
        if(age>100||age<0)
            System.out.println("年龄设置不合法");
        else
            this.age=age;
    }
    public int getAge(){
        return this.age;
    }
    public void setName(String name){
        if(name.length()>10||name.length()<2)
            System.out.println("姓名设置不合法");
        else
            this.name=name;
    }
    public String getName(){
        return this.name;
    }
}

package com.ittht.day03;

public class PersonTest1 {
    public static void main(String[] args) {
        Person1 p=new Person1();
        //p.age=1000;不对，因为Person1类里面的age被屏蔽，要使用对应的setter方法
        p.setAge(1000);//传入的age的值是非法的，访问p的age成员变量要通过对应的getter方法,输出不合法的年龄
        System.out.println("未能设置成员变量时："+p.getAge());//输出0
        p.setAge(30);
        System.out.println("成功设置之后的age："+p.getAge());//输出30
        p.setName("李刚");
        System.out.println("成功设置name成员变量后："+p.getName());//输出李刚
    }
}

 下次总结的时候要把上次学习的 java 总结看一遍，感觉很容易忘记，其实代码实现也很重要，不然真到了写项目的时候都不知道怎么开始，边学习边敲代码很重要。