初学者的学习复习day_7

10/15日学习

一.代码块

概念:
使用{}括起来的代码,成为代码块
分类:
根据它位置和声明的不同,我们可以将代码块分为局部代码块,构造代码块,静态代码块,同步代码块(多线程使用)
a.局部代码块
限定了变量的生命周期,变量在局部代码块中定义的,那么出来局部代码块后,就访问不到了.在局部代码块中定义的变量.
在出了代码块之后,内存就会释放掉.
作用:主要就是节省内存.
局部代码块中定义的变量,虽然说作用域是局部的,但是如果存在外部嵌套的代码块,且在局部代码块定义之前就定义了某个变量
那么我们局部的代码块中就不可以定义相同名称的变量.
但是如果在局部代码块执行之后,去定义一个和局部代码块中相同名称的变量,是可以的.因为局部代码块中的变量已经失去了意义.
eg:public class Text9 {
public static void main(String[]args){
{
int x=10;
}
int x=20;
System.out.println(x);
}
}
输出结果:20
b.构造代码块
概念:类中方法外出现,每次调用构造方法的时候,都会优先调用构造代码块.
特点:每创建一个对象,都会调用一次我们的构造代码块.
作用:如果存在很多重载的构造方法,而且每个里面余姚执行相同的逻辑,那么就可以考虑将这些代码提取到构造
代码块来执行,让我们代码结构更加简洁.增强了维护性.
使用场景其实不太多见.


c.静态代码块
概念:
类中方法外的出现,但是用static来进行修饰.
特点:随着类加载的时候执行.
用处:适用于整个生命周期,只需要执行一次的业务逻辑代码.
比如我们之后数据库的操作
eg:public class Text10 {
static {
System.out.println("demo2静态代码块");
}
public static void main(String[]args){
Teenage teenage=new Teenage();
System.out.println("--------------------------");
    Teenage teenage1=new Teenage(20);
}
}
class Teenage{
int age;
int[]num;
static{
System.out.println("调用了静态代码块");
}
{
//构造代码块
System.out.println("构造代码块");
}
     //默认的构造方法
Teenage(){
System.out.println("默认构造");
//数组成员变量我们以此赋值
}
Teenage(int age){
this.age=age;
System.out.println("非默认构造");
//数组成员变量我们依次赋值
}
  }
输出结果:
demo2静态代码块
调用了静态代码块
构造代码块
默认构造
--------------------------
构造代码块
非默认构造
二.继承
特点
1.子类继承父类,继承父类的成员变量和成员方法.但是他们各自拥有的各自的成员变量,所以他们的值,并不会继承.
2.对于父类中的私有成员变量和私有方法,子类是无法继承的.
继承优点:
a:提高了代码的复用性
b:提高了代码的维护性
继承缺点:
a.类的耦合性增强了.
开发的原则:低耦合,高内聚.
耦合:类与类之间的关系
内聚:自己独立完成某件事情的能力.
电视类:品牌,价格,尺寸
手机类:品牌,价格,尺寸,操作系统
上层抽出来的一个类:电器类(品牌,价格,尺寸)
eg:public class Text11 {
public static void main(String[]args){
television dianshi=new television();
dianshi.setid("康佳");
dianshi.setprice(6300);
System.out.println(dianshi.id+dianshi.price);
     phone ph1=new phone();
     ph1.setid("华为");
     ph1.setprice(2300);
     ph1.getoperate();
     ph1.setsize();
     ph1.speak();
}
}
class television{
 int price;
String id;
int size;
boolean ka;
television(){
}
void setprice(int price){
this.price=price;
}
int getprice(){
return price;
}
void setsize(){
double size=5.5;
this.size=(int) size;
}
int getsize(){
return size;
}
void setid(String id ){
this.id=id;
}
String getid(){
return id;
}
}
class phone extends television{
void getoperate(){
     if(ka){
    System.out.println("安卓");
     }
     else{
    System.out.println("ios");
     }
    
}
void speak(){
System.out.println(id+"    " +price  +"   " + size  +"操作系统是");
}
}
输出结果:
康佳6300
ios
华为    2300   5操作系统是
3.只支持单继承,但是可以支持多层继承
继承是相相互叠加的,子类继承的时候,会递归似的寻找父类中是否还存在继承,会继承整个层级直到最根部类
的属性和方法.


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


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


b.同名的成员变量
优先原则:如果子类中定义了和父类中相同名字的成员变量,会优先访问子类的该变量
如果想要依然访问到父类中的同名变量,我们需要加上super关键字来获取
this: 当前对象的引用
super: 父类对象的引用
this: 可以访问到子类中的变量，也可以访问到父类中的变量
super: 访问父类中的变量
eg:public class Text12 {
public static void main(String[] args){
Son son = new Son();
son.print();
}
}
class Father{
int num1 = 10;
int num2 = 20;

}
class Son extends Father{
int num3 = 30;
int num1 = 40;
void print(){
System.out.println(this.num1+" .. "+this.num2);
System.out.println(super.num1+" .. "+super.num2);
}
}
继承关系中访问成员方法:
a.不同名的方法
子类可以直接调用到父类的方法
b.同名的方法
当父类和子类出现在同名方法中(同名方法:指的返回值类型(父子类关系是可以的)),方法名称
以及方法接受的形参列表要一摸一样
在这种情况下:
当我们子类调用该方法时,会有优先原则的处理,就是会调用子类的该方法.
2:public class Text13 {
public static void main(String[] args){
Son son = new Son();
son.speak();
son.eat();
}
}
class Father{
static  void speak(){
System.out.println("father speak");
}
}
class Son extends Father{
void eat(){
System.out.println("eat");
super.speak();
}
static void speak(){
System.out.println("son speak");
}
}
输出结果
son speak
eat
father speak


方法的重写:
存在于继承关系中,子类中定义的方法和父类中得方法完全一样的时候(返回值类型父子类关系是可以的)
我们在通过子类对象来访问该方法的时候,就会调用到子类的方法.


方法重写注意事项:
子类不能重写父类的私有方法.
子类重写父类方法的时候,提供的访问权限不能更低.
子类覆盖父类方法,如果父类是静态方法的话,子类也必须是静态方法才可以成功覆盖,也就是重写.


方法重载:
同一个类中,如果我们多个相同方法名的方法,但是他们的形参列表是不同的.那么这种方法我们成为方法重载.
在调用的时候,jvm能够通过不同的形参来区分到我们到底调用的是那个方法.


关于方法重写和方法重载的返回值约束:
方法重载:仅返回值不同是不能重载的.要求返回值类型也要相同.


this:可以访问子类的方法,也可以访问父类的方法.
super:只能访问父类的方法.
eg:public class Texts14 {
 public static void main(String[]args){
Son son1=new Son();
System.out.println("-------------");
}
}
class Mather{
Mather(){
System.out.println("Mather 默认构造");
}
Mather(int num){
System.out.println("Mather 有参构造");
}
}
class smallSon extends Mather{
smallSon(){
this(10); 
System.out.println("smallson默认构造");
}
smallSon(int num){
super();
System.out.println("smallson有参构造");
}
}
练习:正方形 长方形
eg:
 
public class text15 {
public static void main(String[]args){
Square square =new Square();
System.out.println(square.getSumLenth());
System.out.println(square.getArea());

Rectangle rectangle =new Rectangle();
System.out.println(rectangle.getSumLength());
System.out.println(rectangle.getArea());
}
}
class Square{
private int lengthOfSide=10;
int getSumLenth(){
return 4*lengthOfSide;
}
int getArea(){
return lengthOfSide*lengthOfSide;
}
}


class  Rectangle extends Square{
int width=4;
int height =5;
int getSumLength(){
return(width +height)*2;
}
int getArea(){
return width*height;
}
}
我们一个文件在jvm编译后产生的.class文件的数量,取决于在该文件中定义的class的数量.(非内部类)
而且是不引入其他类的情况下.


继承中构造方法的调用:
特点:
1.创建子类对象的时候,一定会优先去创建父类的对象.因为要创建父类对象,所以就需要去调用到父类的构造方法.
2.对于我们所有的类的构造方法的第一行,第一行在我们没有自己添加this(...)或者super(...)的情况下都会去帮
我们默认的添加super()


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


明确一点:
a.一定要保证父类对象的创建成功.
b.构造方法的第一行,如果我们添加了自己调用this(...),或super(...),系统就不会为我们添加super().
c.我们的this(...)或者super(...)必须放到第一行.二者只能有其一.


三.final关键字
a.final修饰符
final如果修饰一个类,该类不能被继承.


b.final修饰符一个类,该类不能被继承.
该成员变量的值不可修改.
问题:那么什么时候初始化这个值?


在对象创建之间都可以.
a.构造代码块中可以进行初始化
b.构造方法中可以初始化
c.定义成员方法变量的时候,可以直接进行初始化.


注意点:这三种方式同时只能一种.
再大多数的场景下,我们的final成员变量都会配合public static 一起使用.


//常量类,变量命名都要大写,而且单词之间要用_分隔开
class A{
    public static final double PI=3.14;
    public static final double RATE=2.86;
}
A.PI
A.RATE


静态成员变量的初始化时机:
a.在创建静态final成员变量的时候,直接进行初始化.
b.在静态代码块中进行初始化.
}
eg:public class Text16 {
public static void main(String[]args){
Person person =new Person();
person.sayNum();
}
}
class Person{
static final int num;//在创建静态final成员变量的时候，直接进行初始化。
static{   //在静态代码块中进行初始化.
num=10;
}
Person(){
}
  void sayNum(){
 System.out.println(num);
  }
}
调用方法:
先生成一个数 再生成10随机小于10的数:
public class Text17 {
 public static void main(String[]args){
int num=(int) (Math.random()*11);
System.out.println(num);
for(int i=0;i<10;i++){
System.out.print((int)(Math.random()*11)+"  ");
}
 }
}
输出结果:
8
9  8  4  4  9  5  1  5  2  8  


定义一个保存int型的数组,并且初始化0-27的随机值,之后进行升序排序.
eg:import java.util.Arrays;
public class Text18 {
 public static void main(String[]args){
int []arr=new int[10];
for(int i=0;i<10;i++){
arr[i]=(int)(Math.random()*28);
}
System.out.println("未排序的数组为"+Arrays.toString(arr));
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
 }
}
输出结果:
未排序的数组为[21, 21, 24, 19, 23, 22, 22, 20, 16, 15]
[15, 16, 19, 20, 21, 21, 22, 22, 23, 24]