day06-day07基础知识梳理

day06

一.匿名对象

     1.定义：没有名字的对象。

    2.意义：节省代码，并且很多情况下是针对某个方法只需要调用一次的情况下。

    3.作用：（1）可以调用方法。

          （2）可以给成员变量赋值。

          （3）可以作为方法的参数进行传递。

    4.主要作用：节省代码量，使代码结构更优雅。

二.封装

   1.概念：隐藏对象的属性和细节，仅对外提供公共的方法进行访问。

    2.（1）private

      a.当类的成员变量使用private修饰符修饰，那么就不可以直接访问到该成员变量。

      b.当使用private修饰的成员变量或者方法，仅能在本类中使用。

      c.private对于main()方法的修饰，也是可以产生作用的。

      （2）javaBean

      是这样一类的类：

          它的所有成员变量都使用private进行修饰，并且对外提供可访问的设置值和获取值的set，get方法。

          不同的应用场景，可能命名不同。数据库中的应用称为POJO类。

      （3）main方法细节：

       a.每个类中都可以存在main（）方法，但是执行的时候，会优先查看public的class中是否有main（）方法。

       b.如果没有public的class，那么会按照文件名优先查找类中的main()方法。

       c.必须定义为public。

       例子：

public class Demo1{public static void main(String[] args){/*Person person = new Person();person.name="diffo";person.age = 20;person.speak();*///new Person("diffo",20).speak();Person person = new Person();person.initPerson(person);person.speak();initPerson(new Person()).speak();//参数为匿名对象}//定义的名称，是针对person对象初始化的。static Person initPerson(Person person){person.name="diffo";person.age = 22;return person;}}class Person{String name;int age;Person(){//默认构造器}Person(String nameParm,int ageParm){//构造器

name = nameParm;age = ageParm;}void initPerson(Person person){person.name="diffo";person.age = 22;}void speak(){System.out.println("speak!: "+name+" . "+age);}}

三.优先原则

   对于一个方法说，如果传递的形参的变量名称和类的成员变量名称相同，虚拟机会优先当做方法的形参来处理。

四.this关键字

   1.含义：代表了当前对象的引用。

            可以理解为，当前谁来调用，this就代表谁。

    2.用法：a.对于成员变量可以区分出来的场景，this可加也可以不加，实际效果相同。

            但是对于实现javaBean/POJO来说，我们建议都加上在setXXX，getXXX方法中。

            b.this可以加在成员变量前面来指定对应的引用，也可以加在成员方法的前面。

例子：

//java beanclass Person{private String name;private int age;void setName(String nameParm){name = nameParm;}String getName(){return name;}void setAge(int ageParm){age = ageParm;}int getAge(){return age;}void speak(){System.out.println(name+" . "+age);}public static void main(String[] args){Person person = new Person();person.setName("diffo");person.setAge(30);person.speak();}}class DemoBean{static void main(String[] args){Person person = new Person();person.setName("diffo");person.setAge(30);person.speak();}}

五.初始化类成员变量的方式

    方式一：在构造方法执行前进行赋值，并且该类每个实现的对象，都会被初始化为该值。

             意义：当我们真的需要一个类的所有对象某些成员变量的值一致的时候。

      方式二：提供外界可访问到的方法，在方法中进行赋值。

             意义：动态的修改成员变量的值。

      方式三：通过构造方法进行直接赋值

              意义：可以在创建对象的同时进行赋值，同时还可以动态的指定设定的值是什么。

      

      例子：

public class DemoClassTest{public static void main(String[] args){//第一种方式://在构造方法执行前进行赋值，并且该类每个实现的对象，都会被初始化为该值.//意义: 当我们真的需要一个类的所有对象某些成员变量的值一致的时候。Person person = new Person();person.entity = "Japan";person.showEntity();//第二种方式//构造方法中直接进行赋值.//意义： 可以在创建对象的同时进行赋值，同时还可以动态的指定设定的值是什么Person person1 = new Person(40);person1.showEntity();//第三种方式//通过调用某个设置值的方法进行赋值,在对象创建完成之后//意义: 动态的修改成员变量的值.Person person2 = new Person();person2.showEntity();//person.age = 12 //error/*person.setAge(12);person.eat();Person person1 = new Person();person1.setAge(15);person1.eat();*/}}class Person{//改成员变量就不可被外部访问(外部: 类之外)int age=20;static String entity;//是给成员变量赋值//优先原则: 对于一个方法来说，如果传递的形参的变量名称和类的成员变量名称相同，jvm在处理的时候优先当做方法的形参来处理.Person(){}Person(int age){this.age = age;}void setAge(int age){this.age = age;}//拿到成员变量的值int getAge(){return this.age; }void eat(){System.out.println("eat :"+this.age);speak();}void outputAge(){System.out.println(this.age);}void speak(){System.out.println("speak!");}void showEntity(){System.out.println("Entity:"+entity);}}

六.static

   a.随着类加载而加载（静态方法区中来保存静态成员变量）

    b.优先于对象创建。 

    c.被类的所有对象共享，静态的成员变量会保存在该class的静态方法区中，所以每个对象都看到的都是同一份。

    d.可以通过类名来访问也可以通过对象名来访问。（效果是一样的）

    e.推荐通过类名来访问。

    f.静态的成员，一般称为类相关的成员。

      static 既可以修饰成员变量，也可以修饰成员方法，且修饰之后，就可以通过类名来直接访问到。

    g.this变量在静态方法中不可以使用。

    h.静态方法中只能访问静态成员变量和静态方法。

      非静态方法既可以访问静态成员和方法，也可以访问非静态成员和方法。

      非静态方法虽然可以访问静态方法，但不介意这样做。

例子：

public class DemoStatic{public static void main(String[] args){Person person = new Person();Person.action();//Person.speak();/*person.name="ryan";System.out.println(new Person().name);System.out.println(Person.name);*/method();}static void method(){System.out.println("method");}}class Person{static String name = "diffo";static int age = 20;void speak(){System.out.println("speak:"+age);}static void action(){speak();}}

七.main方法

   修饰符 返回类型 方法名（参数列表）{

}

     public static void main（String[] args）{

}

public:最大的一个访问权限，使得jvm能够成功调用。

static：类相关的，与对象无关。A.main（[]）;

       public class A{

       main(){

       System.("");

}

}

void:不需要返回值。

方法名：main

参数列表：执行的时候，可以传递参数。

八.工具类

   全部都是静态的方法，所以可以通过类名.function（）来访问。

     一般的话，都会对默认构造方法进行私有化处理，来防止别人使用时习惯性的创建对象来调用方法。

例子：

//工具类: 都是把其中的方法定义为staticpublic class MathUtil{//加法static int sum(int num1,int num2){return num1+num2;}//减法，乘法     private MathUtil(){}public static void main(String[] args){System.out.println(MathUtil.sum(2,3));new User().getResult();}}class User{void getResult(){System.out.println(MathUtil.sum(2,3));}}

day07

一.代码块

   1.概念：使用{}括起来的代码，称为代码块。

    2.分类：根据它的位置和声明的不同，我们可以将代码块分为局部代码块，构造代码块，静态代码块，同步代码             块（多线程中涉及）。

      （1）局部代码块：限定了变量的生命周期，变量在局部代码块中定义的，那么出来局部代码块之后，就访问                        不到了。在局部代码块中定义的变量在出了代码块之后，内存就会释放掉。

           作用：节约内存。

           注意：局部代码中定义的变量，虽然说作用域是局部的，但是如果存在外部嵌套的代码块，且在局部代              码块定义之前就定义了某个变量，那么我们局部的代码块中就不可以定义相同名称的变量。

                 但是如果在局部代码块执行之后，去定义一个和局部代码块中相同名称的变量，是可以的。因为              局部代码块中的变量已经失去了作用域范围。

           例：

            public static void main(String[] args){

             int x=20;//错误

              {

int x=10;

}

int x=20;//正确，上面代码块释放

                System.out.println(x);

            }

       (2)构造代码快

           a.概念：类中方法外出现，每次调用构造方法的时候，都会优先调用构造代码块。

           b.特点：创建一个对象，都会调用一次构造代码块。

           c.作用：如果存在很多重载的构造方法，而且每个里面需要执行相同的逻辑，那么就可以考虑，将这些                    代码提取到构造代码块中来；让代码结构更简单，增强了维护性。

     （3）静态代码块

          a.概念：类中方法外出现，但是用static来进行修饰。

          b.特点：随着类加载的时候执行。

          c.用处：适用于整个软件生命周期中，只需要执行一次业务逻辑代码。

二.继承

   1.子类继承父类，继承父类的成员变量和成员方法。但是他们各自拥有的各自的成员变量，所以他们的值，并不       会继承。

      2.对于父类中的私有成员变量和私有方法，子类是无法继承的。

     继承的优点：

        a.提高了代码的复用性。

        b.提高了代码的维护性。

     继承的缺点：

        类的耦合性增强了。

        开发的原则：高内聚，低耦合。

     3.只支持单继承，但是可以支持多层继承。

       继承是相互叠加的，子类继承的时候，会递归似的寻找父类中是否还存在继承，会继承整个层级直到最根部        类的属性和方法。

     4.对于构造方法是无法继承的，但是有办法可以调用父类的构造方法。

     5.继承关系中访问成员变量：

       （1）不同名的成员变量：

            子类可以直接访问和使用父类继承的非私有的成员变量

       （2）同名的成员变量：

            优先原则：如果子类继承了和父类中相同名字的成员变量，会优先访问子类的该变量。

                      如果依然想要访问到父类中的同名变量，我们需要加上super关键字来获取。

            this：当前对象的引用，可以访问到子类中的变量，也可以访问到父类中的变量。

            super:父类对象的引用，只可以访问父类中的变量。

    6.继承关系中访问成员方法：

       （1）不同名的方法：子类可以直接调用父类的方法。

       （2）同名的方法：（同名方法：返回值类型，方法名称以及方法接收的形参列表要一模一样）

                         当父类和子类出现同名方法的时候，在这种情况下，当我们子类调用该方法时，会有优                          先原则的处理，就是会调用子类的该方法。

    7.方法的重写：存在于继承关系中，子类中定义的方法和父类中的方法完全一样的时候（返回值类型父子类关系       是可以的），我们在通过子类访问该方法的时候，就会调用到子类的方法。

      方法重载：同一个类中，如果我们有多个相同方法名的方法但是他们的形参列表是不同的，那么这种方式我们                 就称为方法的重载。在调用的时候，jvm能够通过不同的形参来区分我们到底调用的是哪个方法。

    8.关于方法重写和方法重载的返回值约束：

       方法重载：仅返回值不同是不能重载的，必须参数列表不同。

       方法重写：返回值类型（父子类关系是可以的）要求返回值类型也要相同的。

  补充：

       我们一个文件在编译之后产生的.class文件的数量，取决于该文件中定义的class的数量（非内部类）而且是        不引入其他类的情况下。

    9.继承中构造方法的调用：

      特点：

      （1）创建子类对象的时候，一定会优先去创建父类对象，所以就需要调用到父类的构造方法。

      （2）对于我们所有的类构造方法的第一行，如果我们没有自己添加this（...）或者super(...)的情况下，都            会去帮我们默认的添加super（）.

       如果父类中不存在默认的构造，子类依然要创建对象，那么子类就需要显示的指明调用的是哪一个父类对          象，才能保证父类对象创建的成功。

      明确一点：

        a.一定要保证父类对象的创建成功。

        b.构造方法的第一行，如果我们添加了自己调用的this（...）或者super（...），系统就不会为我们默认           的添加super().

        c.我们的this(...)或者super（...）必须放到第一行，二者只能有其一。

三.final关键字

   a.final修饰类

      final如果修饰一个类，该类不能被继承。

    b.修饰类的成员变量（修饰成员变量，该值不可改变）。

      问题：那么什么时候初始化这个值？

        答：在对象创建之前都可以。

      （1）构造代码块中可以进行初始化

      （2）构造方法中可以进行初始化

      （3）定义成员变量的时候，可以直接进行初始化

      注意：三种方式同时只能使用一种。

            在大多数的场景下，我们的final成员变量会配合public static一起使用。

             例：class A{

               public static final double PI=3.14;

              }//常量类，变量名都要大写，而且单词之间要用_分隔开

     c.静态成员变量初始化时机：

       （1）在创建静态final成员变量的时候，直接进行初始化

       （2）在静态代码块中进行初始化。

作业：

1.

package task;/*1. 定义一个工具类其中提供了对于整形数组和double类型数组的一些工具方法。方法分别有:1.求数组值的和.2.求数组中的最大值3.对数组进行升序排序.4.对数组进行倒序排序(也就是反转数组)工具类要求:a.私有化构造方法b.不希望被继承*/public class Tools {private Tools(){//私有化默认构造方法}public static void main(String[] args){Tools tools=new Tools();//静态初始化//int[]arr=new int[]{7,9,2,0,1,6,4,3,5,8};//tools.intArrAdd(arr);//tools.intArrMax(arr);//tools.intSortAsc(arr);//tools.intArrRev(arr);double[]arr=new double[]{7.03,9.08,2.07,0.0,1.23,6.67,4.71,3.09,5.33,8.21};tools.doubleArrRev(arr);}private void intArrAdd(int []arr){//数组的和int sum=0;for(int i=0;i<arr.length;i++){sum+=arr[i];}System.out.println("数组的和为："+sum);;}private void intArrMax(int[]arr){//数组中的最大数int max=0;for(int i=0;i<arr.length;i++){if(max<arr[i]){max=arr[i];}}System.out.println("数组中最大的数为："+max);;}private void intSortAsc(int[]arr){//使用选择排序进行升序排序int temp;System.out.println("升序排序后的数组为：");for(int i=0;i<arr.length;i++){for(int j=i+1;j<arr.length;j++){if(arr[i]>arr[j]){temp=arr[i];arr[i]=arr[j];arr[j]=temp;}}System.out.print(arr[i]);System.out.print(" ");}} private void intArrRev(int[]arr){//反转数组int temp;System.out.println("反转后的数组为：");for(int i=0;i<arr.length/2;i++){temp=arr[i];arr[i]=arr[arr.length-1-i];arr[arr.length-1-i]=temp;}for(int i=0;i<arr.length;i++){System.out.print(arr[i]);System.out.print(" ");} }private void doubleArrAdd(double []arr){//数组的和double sum=0;for(int i=0;i<arr.length;i++){sum+=arr[i];}System.out.println("数组的和为："+sum);;}private void doubleArrMax(double[]arr){//数组中的最大数double max=0;for(int i=0;i<arr.length;i++){if(max<arr[i]){max=arr[i];}}System.out.println("数组中最大的数为："+max);;}private void doubleSortAsc(double[]arr){//使用选择排序进行升序排序double temp;System.out.println("升序排序后的数组为：");for(int i=0;i<arr.length;i++){for(int j=i+1;j<arr.length;j++){if(arr[i]>arr[j]){temp=arr[i];arr[i]=arr[j];arr[j]=temp;}}System.out.print(arr[i]);System.out.print(" ");}} private void doubleArrRev(double[]arr){//反转数组double temp;System.out.println("反转后的数组为：");for(int i=0;i<arr.length/2;i++){temp=arr[i];arr[i]=arr[arr.length-1-i];arr[arr.length-1-i]=temp;}for(int i=0;i<arr.length;i++){System.out.print(arr[i]);System.out.print(" ");}}}

2.

package task;/*a.定义一个英雄类  Hero 属性:(全部私有，提供公共方法让外部访问)        年龄, 血量 ，攻击力，防御力  方法:释放技能，加血.   必须至少包含一个构造方法，且该构造方法可以初始化所有四个成员变量      b.定义一个类BatMan继承Hero类 方法:飞行(方法中输出一行打印"飞行")   c.定义一个SuperBatMan类继承 BatMan类   方法:重写飞行方法(方法中输出一行打印"超级飞行")   最终分别创建BatMan对象和SuperBatMan对象，并调用飞行方法.*/public class Hero {Hero(){age=18;blood=100;attack=100;defend=100;}private int age;private int blood;private int attack;private int defend;void releaseSkills(){System.out.println("释放技能");}void addBlood(){System.out.println("加血");}public static void main(String[] args){BatMan batman=new BatMan();batman.fly();batman.releaseSkills();batman.addBlood();SuperBatMan superbatman=new SuperBatMan();superbatman.fly();superbatman.releaseSkills();superbatman.addBlood();}}class BatMan extends Hero{void fly(){System.out.println("飞行");}} class SuperBatMan extends BatMan{void fly(){System.out.println("超级飞行");}}

3.

 

package task;import java.util.*;/*实现一个猜数的小游戏.随机产生一个数(a)。Scanner 的方式来输入一个数字，并提供反馈,告诉用户该输入的值比a大还是比a小，直到最终用户猜中，显示结果.   */public class Task3 {int num;int a;void inputNum(){Random d=new Random();int a=d.nextInt(10);System.out.println("请输入一个数字：");Scanner sc=new Scanner(System.in);num=sc.nextInt();if(num<a){System.out.println("输入的值比a小，请重新输入!");inputNum();}else if(num>a){System.out.println("输入的值比a大，请重新输入!");inputNum();}else{System.out.println("恭喜你猜中了！本次产生的随机数是:"+num);}}public static void main(String[] args){Task3 t=new Task3();t.inputNum(); }}

c语言作业

1.

#include <stdio.h>
//给你任意三个整型数据，找出其中最大一个整型数
void main(){
int arr[3];
printf("请输入任意三个整型数据:\n");
scanf("%d %d %d" ,&arr[0],&arr[1],&arr[2]);
    int max=0;
for(int i=0;i<3;i++){
if(arr[i]>max){
max=arr[i];
}
}
printf("最大的一个整型数是：%d\n",max);


}

2.#include<stdio.h>
//求1+2!+3!+...+20!的和
void main(){
int sum=0;
int mul=1;
for(int i=1;i<=20;i++){
for(int j=1;j<=i;j++){
mul*=j;

}
sum+=mul;
}
printf("1+2!+3!+...+20!的和为: %d\n",sum);
}

3.#include<stdio.h>
//编程完成数据加密，数据是五位的整数，加密规则为：每位数字都加上6，然后用和除以8的余数代替该数字，再将第一位和第五位交换，第二位和第四位交换
void main(){
int a;
printf("请输入要加密的五位的整数：\n");
scanf("%d",&a);
//得到每一位的数字
int b1=a/10000;
int b2=(a%(b1*10000))/1000;
int b3=(a%(b1*10000+b2*1000))/100;
int b4=(a%(b1*10000+b2*1000+b3*100))/10;
int b5=a%(b1*10000+b2*1000+b3*100+b4*10);
//加上6，和除以8取余
int c1=(b1+6)%8;
int c2=(b2+6)%8;
int c3=(b3+6)%8;
int c4=(b4+6)%8;
int c5=(b5+6)%8;
//交换
int temp1,temp2;
temp1=c1;
c1=c5;
c5=temp1;
temp2=c2;
c2=c4;
c4=temp2;
int sum=c1*10000+c2*1000+c3*100+c4*10+c5;
printf("加密后的数字为：%d\n",sum);

}